{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1jrRNDcXby7sZYL9B-ZcDvBI0FcR843em","timestamp":1743542510065}],"authorship_tag":"ABX9TyOdEmKtVpAyjGaL72z4EaWI"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","source":["import pandas as pd  # Data manipulation\n","import matplotlib.pyplot as plt  # Plotting graphs\n","import seaborn as sns  # Enhanced visualizations\n","from sklearn.model_selection import train_test_split, GridSearchCV  # Splitting data & hyperparameter tuning\n","from sklearn.preprocessing import LabelEncoder, StandardScaler  # Encoding categorical data & standardizing\n","from sklearn.impute import SimpleImputer  # Handling missing values\n","from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, HistGradientBoostingClassifier  # Ensemble models\n","from sklearn.linear_model import LogisticRegression  # Logistic regression model\n","from sklearn.neural_network import MLPClassifier  # Neural network model\n","from sklearn.svm import SVC  # Support Vector Machine\n","from sklearn.metrics import accuracy_score, classification_report, confusion_matrix  # Model evaluation metrics\n","import numpy as np  # Numerical computations\n","from sklearn.ensemble import VotingClassifier  # Combining models for better predictions\n","\n","# Load dataset\n","df = pd.read_csv(\"ECGCvdata.csv\")  # Read CSV file into a DataFrame\n","\n","# Selecting features and target variable\n","X = df.drop(columns=[\"RECORD\", \"ECG_signal\"])  # Feature columns\n","y = df[\"ECG_signal\"]  # Target variable\n","\n","# Handling missing values using mean imputation\n","imputer = SimpleImputer(strategy=\"mean\")  # Replacing NaN values with mean\n","X_imputed = imputer.fit_transform(X)\n","\n","# Normalize the feature set\n","scaler = StandardScaler()  # Standardizing features\n","X_scaled = scaler.fit_transform(X_imputed)\n","\n","# Encode target variable\n","label_encoder = LabelEncoder()  # Converting categorical labels to numerical\n","y_encoded = label_encoder.fit_transform(y)\n","\n","# Split data into training and testing sets\n","X_train, X_test, y_train, y_test = train_test_split(\n","    X_scaled, y_encoded, test_size=0.2, random_state=42, stratify=y_encoded\n",")  # 80% training, 20% testing\n","\n","# Define classification models with parallelization for efficiency\n","models = {\n","    \"Logistic Regression\": LogisticRegression(max_iter=1000, n_jobs=-1),\n","    \"Random Forest\": RandomForestClassifier(n_estimators=300, max_depth=20, random_state=42, n_jobs=-1),\n","    \"Gradient Boosting\": GradientBoostingClassifier(n_estimators=300, learning_rate=0.05, random_state=42),\n","    \"HistGradientBoosting\": HistGradientBoostingClassifier(max_iter=100, random_state=42),\n","    \"Support Vector Machine\": SVC(kernel='rbf', probability=True),  # SVC does not support n_jobs\n","    \"Neural Network\": MLPClassifier(hidden_layer_sizes=(300, 150), max_iter=1000, random_state=42)  # MLP does not support n_jobs\n","}\n","\n","best_model = None\n","best_accuracy = 0\n","\n","# Train and evaluate multiple models\n","for name, model in models.items():\n","    model.fit(X_train, y_train)  # Train model\n","    y_pred = model.predict(X_test)  # Make predictions\n","    accuracy = accuracy_score(y_test, y_pred)  # Calculate accuracy\n","    print(f\"{name} Accuracy: {accuracy:.4f}\")\n","    print(\"Classification Report:\\n\", classification_report(y_test, y_pred, target_names=label_encoder.classes_))\n","\n","    if accuracy > best_accuracy:  # Track the best performing model\n","        best_accuracy = accuracy\n","        best_model = model\n","\n","# Function to predict disease for a given input feature set\n","def predict_disease(features):\n","    features_scaled = scaler.transform([features])  # Scale input features\n","    prediction = best_model.predict(features_scaled)  # Predict using best model\n","    return label_encoder.inverse_transform(prediction)[0]  # Return original label\n","\n","# Voting Classifier to combine multiple models for improved predictions\n","voting_clf = VotingClassifier(estimators=[\n","    (\"log_reg\", models[\"Logistic Regression\"]),\n","    (\"rf\", models[\"Random Forest\"]),\n","    (\"svc\", models[\"Support Vector Machine\"])\n","], voting=\"hard\", n_jobs=-1)  # Hard voting means majority rule\n","\n","voting_clf.fit(X_train, y_train)  # Train voting classifier\n","y_pred_voting = voting_clf.predict(X_test)  # Make predictions\n","accuracy_voting = accuracy_score(y_test, y_pred_voting)  # Evaluate accuracy\n","print(f\"Voting Classifier Accuracy: {accuracy_voting:.4f}\")\n","\n","# Confusion Matrix for Best Model\n","y_pred_best = best_model.predict(X_test)\n","cm = confusion_matrix(y_test, y_pred_best)  # Compute confusion matrix\n","plt.figure(figsize=(8, 6))\n","sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_)\n","plt.title(\"Confusion Matrix\")\n","plt.xlabel(\"Predicted\")\n","plt.ylabel(\"Actual\")\n","plt.show()\n","\n","# Feature Importance for Tree-Based Models\n","if hasattr(best_model, \"feature_importances_\"):\n","    importances = best_model.feature_importances_  # Get feature importances\n","    indices = np.argsort(importances)[-10:]  # Select top 10 features\n","    plt.figure(figsize=(10, 6))\n","    plt.barh(range(len(indices)), importances[indices], align='center')  # Horizontal bar chart\n","    plt.yticks(range(len(indices)), [df.columns[i] for i in indices])\n","    plt.xlabel(\"Relative Importance\")\n","    plt.title(\"Top 10 Important Features\")\n","    plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"IYPhIVZPD49n","executionInfo":{"status":"ok","timestamp":1743540789396,"user_tz":-360,"elapsed":40713,"user":{"displayName":"Hasib Al Tahsin","userId":"09702867651229494535"}},"outputId":"a33949c9-a02f-4e99-8310-feb5bec18f33"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Logistic Regression Accuracy: 0.9583\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","         AFF       0.95      0.88      0.91        60\n","         ARR       1.00      1.00      1.00        60\n","         CHF       0.89      0.95      0.92        60\n","         NSR       1.00      1.00      1.00        60\n","\n","    accuracy                           0.96       240\n","   macro avg       0.96      0.96      0.96       240\n","weighted avg       0.96      0.96      0.96       240\n","\n","Random Forest Accuracy: 0.9708\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","         AFF       0.95      0.95      0.95        60\n","         ARR       0.98      1.00      0.99        60\n","         CHF       0.95      0.93      0.94        60\n","         NSR       1.00      1.00      1.00        60\n","\n","    accuracy                           0.97       240\n","   macro avg       0.97      0.97      0.97       240\n","weighted avg       0.97      0.97      0.97       240\n","\n","Gradient Boosting Accuracy: 0.9667\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","         AFF       0.94      0.97      0.95        60\n","         ARR       0.97      0.98      0.98        60\n","         CHF       0.96      0.92      0.94        60\n","         NSR       1.00      1.00      1.00        60\n","\n","    accuracy                           0.97       240\n","   macro avg       0.97      0.97      0.97       240\n","weighted avg       0.97      0.97      0.97       240\n","\n","HistGradientBoosting Accuracy: 0.9833\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","         AFF       0.97      0.98      0.98        60\n","         ARR       0.98      0.98      0.98        60\n","         CHF       0.98      0.97      0.97        60\n","         NSR       1.00      1.00      1.00        60\n","\n","    accuracy                           0.98       240\n","   macro avg       0.98      0.98      0.98       240\n","weighted avg       0.98      0.98      0.98       240\n","\n","Support Vector Machine Accuracy: 0.9500\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","         AFF       0.89      0.92      0.90        60\n","         ARR       1.00      1.00      1.00        60\n","         CHF       0.91      0.88      0.90        60\n","         NSR       1.00      1.00      1.00        60\n","\n","    accuracy                           0.95       240\n","   macro avg       0.95      0.95      0.95       240\n","weighted avg       0.95      0.95      0.95       240\n","\n","Neural Network Accuracy: 1.0000\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","         AFF       1.00      1.00      1.00        60\n","         ARR       1.00      1.00      1.00        60\n","         CHF       1.00      1.00      1.00        60\n","         NSR       1.00      1.00      1.00        60\n","\n","    accuracy                           1.00       240\n","   macro avg       1.00      1.00      1.00       240\n","weighted avg       1.00      1.00      1.00       240\n","\n","Voting Classifier Accuracy: 0.9667\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 800x600 with 2 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAoAAAAIjCAYAAACTRapjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAATe9JREFUeJzt3XlcVPX+x/H3gDKQCggKSFdF03BfMlOyMpM0c03Nsrrhkpm5lJgZ/lTUSsy0zL2MxCyXrPRmNzWX0kw0l9zTcosUUUQF11Fhfn/0cG4TLmAMZ5zzet7Hefya7/nO93wO506/z/18z/kei91utwsAAACm4WV0AAAAAChcJIAAAAAmQwIIAABgMiSAAAAAJkMCCAAAYDIkgAAAACZDAggAAGAyJIAAAAAmQwIIAABgMiSAAK7rt99+U7NmzRQQECCLxaKFCxcW6PgHDx6UxWJRUlJSgY57K3vwwQf14IMPGh0GAA9GAgjcAvbt26eePXuqYsWK8vX1lb+/vxo1aqT33ntP58+fd+mxY2JitH37dr355puaNWuW7r77bpcerzB16dJFFotF/v7+V/07/vbbb7JYLLJYLBo7dmy+x09NTdXw4cO1ZcuWAogWAApOEaMDAHB9//3vf/X444/LarXq2WefVY0aNXTx4kWtWbNGAwcO1M6dO/XBBx+45Njnz59XcnKy/u///k99+vRxyTHKly+v8+fPq2jRoi4Z/0aKFCmic+fOadGiRerUqZPTvk8//VS+vr66cOHCTY2dmpqqESNGKCIiQnXq1Mnz97799tubOh4A5BUJIODGDhw4oCeffFLly5fXypUrVaZMGce+3r17a+/evfrvf//rsuOnp6dLkgIDA112DIvFIl9fX5eNfyNWq1WNGjXSnDlzciWAs2fPVsuWLfXFF18USiznzp3TbbfdJh8fn0I5HgDzYgoYcGNjxozRmTNnlJiY6JT8XVGpUiW99NJLjs+XL1/W66+/rjvuuENWq1UREREaPHiwbDab0/ciIiLUqlUrrVmzRvfcc498fX1VsWJFffzxx44+w4cPV/ny5SVJAwcOlMViUUREhKQ/p06v/PNfDR8+XBaLxalt2bJluu+++xQYGKjixYsrMjJSgwcPduy/1j2AK1eu1P33369ixYopMDBQbdu21S+//HLV4+3du1ddunRRYGCgAgIC1LVrV507d+7af9i/eeqpp7R48WKdOnXK0bZhwwb99ttveuqpp3L1P3HihF555RXVrFlTxYsXl7+/v1q0aKGtW7c6+nz//feqX7++JKlr166OqeQr5/nggw+qRo0a2rRpkx544AHddtttjr/L3+8BjImJka+vb67zb968uUqWLKnU1NQ8nysASCSAgFtbtGiRKlasqHvvvTdP/Z977jkNGzZMd911l9599101btxYCQkJevLJJ3P13bt3rzp27KiHH35Y48aNU8mSJdWlSxft3LlTktS+fXu9++67kqTOnTtr1qxZGj9+fL7i37lzp1q1aiWbzaaRI0dq3LhxatOmjX788cfrfm/58uVq3ry5jh07puHDhys2NlZr165Vo0aNdPDgwVz9O3XqpNOnTyshIUGdOnVSUlKSRowYkec427dvL4vFoi+//NLRNnv2bFWpUkV33XVXrv779+/XwoUL1apVK73zzjsaOHCgtm/frsaNGzuSsapVq2rkyJGSpOeff16zZs3SrFmz9MADDzjGycjIUIsWLVSnTh2NHz9eTZo0uWp87733nkqXLq2YmBhlZ2dLkt5//319++23mjhxosLDw/N8rgAgSbIDcEuZmZl2Sfa2bdvmqf+WLVvskuzPPfecU/srr7xil2RfuXKlo618+fJ2SfbVq1c72o4dO2a3Wq32AQMGONoOHDhgl2R/++23ncaMiYmxly9fPlcM8fHx9r/+a+Xdd9+1S7Knp6dfM+4rx5gxY4ajrU6dOvaQkBB7RkaGo23r1q12Ly8v+7PPPpvreN26dXMa87HHHrMHBwdf85h/PY9ixYrZ7Xa7vWPHjvamTZva7Xa7PTs72x4WFmYfMWLEVf8GFy5csGdnZ+c6D6vVah85cqSjbcOGDbnO7YrGjRvbJdmnTZt21X2NGzd2alu6dKldkv2NN96w79+/3168eHF7u3btbniOAHA1VAABN5WVlSVJKlGiRJ76f/PNN5Kk2NhYp/YBAwZIUq57BatVq6b777/f8bl06dKKjIzU/v37bzrmv7ty7+B//vMf5eTk5Ok7R44c0ZYtW9SlSxcFBQU52mvVqqWHH37YcZ5/9cILLzh9vv/++5WRkeH4G+bFU089pe+//15paWlauXKl0tLSrjr9K/1536CX15//+szOzlZGRoZjenvz5s15PqbValXXrl3z1LdZs2bq2bOnRo4cqfbt28vX11fvv/9+no8FAH9FAgi4KX9/f0nS6dOn89T/999/l5eXlypVquTUHhYWpsDAQP3+++9O7eXKlcs1RsmSJXXy5MmbjDi3J554Qo0aNdJzzz2n0NBQPfnkk/rss8+umwxeiTMyMjLXvqpVq+r48eM6e/asU/vfz6VkyZKSlK9zefTRR1WiRAnNmzdPn376qerXr5/rb3lFTk6O3n33XVWuXFlWq1WlSpVS6dKltW3bNmVmZub5mLfffnu+HvgYO3asgoKCtGXLFk2YMEEhISF5/i4A/BUJIOCm/P39FR4erh07duTre39/CONavL29r9put9tv+hhX7k+7ws/PT6tXr9by5cv173//W9u2bdMTTzyhhx9+OFfff+KfnMsVVqtV7du318yZM7VgwYJrVv8kadSoUYqNjdUDDzygTz75REuXLtWyZctUvXr1PFc6pT//Pvnx888/69ixY5Kk7du35+u7APBXJICAG2vVqpX27dun5OTkG/YtX768cnJy9Ntvvzm1Hz16VKdOnXI80VsQSpYs6fTE7BV/rzJKkpeXl5o2bap33nlHu3bt0ptvvqmVK1fqu+++u+rYV+Lcs2dPrn27d+9WqVKlVKxYsX92Atfw1FNP6eeff9bp06ev+uDMFZ9//rmaNGmixMREPfnkk2rWrJmio6Nz/U3ymoznxdmzZ9W1a1dVq1ZNzz//vMaMGaMNGzYU2PgAzIUEEHBjr776qooVK6bnnntOR48ezbV/3759eu+99yT9OYUpKdeTuu+8844kqWXLlgUW1x133KHMzExt27bN0XbkyBEtWLDAqd+JEydyfffKgsh/X5rmijJlyqhOnTqaOXOmU0K1Y8cOffvtt47zdIUmTZro9ddf16RJkxQWFnbNft7e3rmqi/Pnz9fhw4ed2q4kqldLlvNr0KBBSklJ0cyZM/XOO+8oIiJCMTEx1/w7AsD1sBA04MbuuOMOzZ49W0888YSqVq3q9CaQtWvXav78+erSpYskqXbt2oqJidEHH3ygU6dOqXHjxvrpp580c+ZMtWvX7ppLjNyMJ598UoMGDdJjjz2mfv366dy5c5o6daruvPNOp4cgRo4cqdWrV6tly5YqX768jh07pilTpuhf//qX7rvvvmuO//bbb6tFixaKiopS9+7ddf78eU2cOFEBAQEaPnx4gZ3H33l5eWnIkCE37NeqVSuNHDlSXbt21b333qvt27fr008/VcWKFZ363XHHHQoMDNS0adNUokQJFStWTA0aNFCFChXyFdfKlSs1ZcoUxcfHO5almTFjhh588EENHTpUY8aMydd4AMAyMMAt4Ndff7X36NHDHhERYffx8bGXKFHC3qhRI/vEiRPtFy5ccPS7dOmSfcSIEfYKFSrYixYtai9btqw9Li7OqY/d/ucyMC1btsx1nL8vP3KtZWDsdrv922+/tdeoUcPu4+Njj4yMtH/yySe5loFZsWKFvW3btvbw8HC7j4+PPTw83N65c2f7r7/+musYf18qZfny5fZGjRrZ/fz87P7+/vbWrVvbd+3a5dTnyvH+vszMjBkz7JLsBw4cuObf1G53XgbmWq61DMyAAQPsZcqUsfv5+dkbNWpkT05OvuryLf/5z3/s1apVsxcpUsTpPBs3bmyvXr36VY/513GysrLs5cuXt9911132S5cuOfXr37+/3cvLy56cnHzdcwCAv7PY7fm4SxoAAAC3PO4BBAAAMBkSQAAAAJMhAQQAADAZEkAAAAA3cvjwYT3zzDMKDg6Wn5+fatasqY0bNzr22+12DRs2TGXKlJGfn5+io6NzrQF7IySAAAAAbuLkyZNq1KiRihYtqsWLF2vXrl0aN26c4xWXkjRmzBhNmDBB06ZN0/r161WsWDE1b95cFy5cyPNxeAoYAADATbz22mv68ccf9cMPP1x1v91uV3h4uAYMGKBXXnlFkpSZmanQ0FAlJSVd9y1Gf0UFEAAAwIVsNpuysrKctmu9xeerr77S3Xffrccff1whISGqW7eupk+f7th/4MABpaWlKTo62tEWEBCgBg0a5Om1oVd45JtA/Or2MToEFKKTGyYZHQIAoAD4GpiVuDJ3GNS2lEaMGOHUFh8ff9U3G+3fv19Tp05VbGysBg8erA0bNqhfv37y8fFRTEyM0tLSJEmhoaFO3wsNDXXsywuPTAABAADcRVxcnGJjY53arFbrVfvm5OTo7rvv1qhRoyRJdevW1Y4dOzRt2jTFxMQUWExMAQMAAFi8XLZZrVb5+/s7bddKAMuUKaNq1ao5tVWtWlUpKSmSpLCwMEnS0aNHnfocPXrUsS8vSAABAAAsFtdt+dCoUSPt2bPHqe3XX39V+fLlJUkVKlRQWFiYVqxY4diflZWl9evXKyoqKs/HYQoYAADATfTv31/33nuvRo0apU6dOumnn37SBx98oA8++ECSZLFY9PLLL+uNN95Q5cqVVaFCBQ0dOlTh4eFq165dno9DAggAAGBxj0nR+vXra8GCBYqLi9PIkSNVoUIFjR8/Xk8//bSjz6uvvqqzZ8/q+eef16lTp3TfffdpyZIl8vX1zfNxPHIdQJ4CNheeAgYAz2DoU8B393fZ2Oc3vuuysW8WFUAAAIB83qt3q3OPeicAAAAKDRVAAAAAN7kHsLCY62wBAABABRAAAMBs9wCSAAIAADAFDAAAAE9GBRAAAMBkU8BUAAEAAEyGCiAAAAD3AAIAAMCTUQEEAADgHkAAAAB4MiqAAAAAJrsHkAQQAACAKWAAAAB4MiqAAAAAJpsCNtfZAgAAgAogAAAAFUAAAAB4NCqAAAAAXjwFDAAAAA9GBRAAAMBk9wCSAAIAALAQNAAAADwZFUAAAACTTQGb62wBAABABRAAAIB7AAEAAODRqAACAABwDyAAAAA8GRVAAAAAk90DSAIIAADAFDAAAAA8GRVAAAAAk00BUwEEAAAwGSqAAAAA3AMIAAAAT0YFEAAAgHsAAQAA4MmoAAIAAHAPYOF49tlndfr0acfnrVu36tKlS0aFAwAAzMzi5brNDRkW1aeffqrz5887Pt9///36448/jAoHAADANAybArbb7df9DAAAUGh4CAQAAACezNCHQHbt2qW0tDRJf1YAd+/erTNnzjj1qVWrlhGhua3w0gF646W2ataoum7zLap9fxxXz+GfaPOuFEefob1aqutj9yqwhJ+St+5Xv1HztC8l3cCoUdDmzv5UM2ck6vjxdN0ZWUWvDR6qmvxWPBbX21y43gZx03v1XMXQs23atKnq1KmjOnXq6Ny5c2rVqpXq1KmjunXrOv4v/iewhJ9WJsXq0uUcteszRXU7vKnX3vlSJ7POOfoM6BKtFzs3Vr9Rc/XAs2N19vxFLZrcW1YfHvj2FEsWf6OxYxLU88Xemjt/gSIjq6hXz+7KyMgwOjS4ANfbXLjeKCwWu0E33/3+++956le+fPl8j+1Xt0++v3MreL1fG0XVrqjo7uOv2Wf/t29qwqyVGj9rhSTJv7ivfl+eoOfjP9H8pZsKKdLCdXLDJKNDKFRPP/m4qteoqcFDhkmScnJy1KxpY3V+6t/q3uN5g6NDQeN6m4vZr7evgbUKv3YfuGzs8wvd79oZ9qe+mcTO7Fo2rqnla3/Rp2O66b56lZV67JQ++OwHzViwVpIUcXuwypQO0Mr1ux3fyTpzQRt2HFSDWhEemwCayaWLF/XLrp3q3qOno83Ly0sNG96rbVt/NjAyuALX21y43ihMt/w6gDabTVlZWU6bPSe7IEN1GxVuL6Uej9+vvSnpavPiZE2fv0bjXu2op1s3kCSFlfKXJB07cdrpe8cyTis02L/Q40XBO3nqpLKzsxUcHOzUHhwcrOPHjxsUFVyF620uXG+DsQ5g4SiodQATEhIUEBDgtF0+6pmVLi8vi7bs/kPxkxZp655D+ujLHzVjwVr16Hif0aEBAHBrs1hct7khwxLAgloHMC4uTpmZmU5bkdB6BRGi20k7nqVf9qc5te0+kKayYSUd+yUpJKiEU5+Q4BI6mpFVOEHCpUoGlpS3t3euG8IzMjJUqlQpg6KCq3C9zYXrjcLknnXJfLBarfL393faLF7eRoflEslb9uvO8iFObZXLhSjlyAlJ0sHDGTqSnqkmDSId+0sU81X9GhFav+1gYYYKFynq46Oq1apr/bpkR1tOTo7Wr09Wrdo8Ne9puN7mwvU2lsVicdnmjlgH8BYy8ZOV+i5pgAZ2a6Yvlm1W/eoR6tahkfq8PsfRZ/Ls7zTouUe0NyVdBw9nKP7FljqSnqmvvttqYOQoSP+O6aqhgwepevUaqlGzlj6ZNVPnz59Xu8faGx0aXIDrbS5cbxQWQxPApk2bOk39tmrVymm/xWJRdrZnPtBxMzbtStETA6ZrZN82Gvx8Cx08nKGBb3+huYs3OvqMS1qu2/ysmjSkswJL+Gntln1q03uKbBcvGxg5CtIjLR7VyRMnNGXSBB0/nq7IKlU15f0PFcwUkUfiepsL19s47lqpcxW3Xgfw9OnTqlGjRr7H9tR1AHF1ZlsHEAA8lZHrABbrOMNlY5/9vKvLxr5ZbrcO4OnTpzVnzhwlJiZq48aNVAABAIDrmasA6D4PgaxevVoxMTEqU6aMxo4dqyZNmmjdunVGhwUAAOBxDL0HMC0tTUlJSUpMTFRWVpY6deokm82mhQsXqlq1akaGBgAATMRs9wAaVgFs3bq1IiMjtW3bNo0fP16pqamaOHGiUeEAAAATYxmYQrJ48WL169dPvXr1UuXKlY0KAwAAwHQMqwCuWbNGp0+fVr169dSgQQNNmjSJdx0CAABDmK0CaFgC2LBhQ02fPl1HjhxRz549NXfuXIWHhysnJ0fLli3T6dOnjQoNAADAoxn+FHCxYsXUrVs3rVmzRtu3b9eAAQM0evRohYSEqE2bNkaHBwAATIAKoIEiIyM1ZswYHTp0SHPmzLnxFwAAAJBvhi4Dcy3e3t5q166d2rVrZ3QoAADADNyzUOcyblUBBAAAMLPhw4fnmkKuUqWKY/+FCxfUu3dvBQcHq3jx4urQoYOOHj2a7+OQAAIAANNzp3sAq1evriNHjji2NWvWOPb1799fixYt0vz587Vq1Sqlpqaqffv2+T6GW04BAwAAmFWRIkUUFhaWqz0zM1OJiYmaPXu2HnroIUnSjBkzVLVqVa1bt04NGzbM8zGoAAIAANNzZQXQZrMpKyvLabPZbNeM5bffflN4eLgqVqyop59+WikpKZKkTZs26dKlS4qOjnb0rVKlisqVK6fk5OR8nS8JIAAAMD1XJoAJCQkKCAhw2hISEq4aR4MGDZSUlKQlS5Zo6tSpOnDggO6//36dPn1aaWlp8vHxUWBgoNN3QkNDlZaWlq/zZQoYAADAheLi4hQbG+vUZrVar9q3RYsWjn+uVauWGjRooPLly+uzzz6Tn59fgcVEAggAAEzPlQs2W63WayZ8NxIYGKg777xTe/fu1cMPP6yLFy/q1KlTTlXAo0ePXvWewethChgAAMBNnTlzRvv27VOZMmVUr149FS1aVCtWrHDs37Nnj1JSUhQVFZWvcakAAgAAuMlC0K+88opat26t8uXLKzU1VfHx8fL29lbnzp0VEBCg7t27KzY2VkFBQfL391ffvn0VFRWVryeAJRJAAAAAt3Ho0CF17txZGRkZKl26tO677z6tW7dOpUuXliS9++678vLyUocOHWSz2dS8eXNNmTIl38ex2O12e0EHbzS/un2MDgGF6OSGSUaHAAAoAL4GlqVKdZnrsrGPJz3psrFvFvcAAgAAmAxTwAAAwPRc+RSwOyIBBAAApme2BJApYAAAAJOhAggAAGCuAiAVQAAAALOhAggAAEyPewABAADg0agAAgAA06MCCAAAAI9GBRAAAJie2SqAJIAAAMD0zJYAMgUMAABgMlQAAQAAzFUApAIIAABgNlQAAQCA6XEPIAAAADwaFUAAAGB6VAABAADg0agAAgAA0zNbBZAEEAAAwFz5H1PAAAAAZkMFEAAAmJ7ZpoCpAAIAAJgMFUAAAGB6VAABAADg0agAAgAA06MCCAAAAI9GBRAAAJie2SqAJIAAAADmyv+YAgYAADAbj6wAntwwyegQUIhK1u9jdAgoRPy+AbiC2aaAqQACAACYjEdWAAEAAPKDCiAAAAA8GhVAAABgeiYrAFIBBAAAMBsqgAAAwPTMdg8gCSAAADA9k+V/TAEDAACYDRVAAABgemabAqYCCAAAYDJUAAEAgOmZrABIBRAAAMBsqAACAADT8/IyVwmQCiAAAIDJUAEEAACmZ7Z7AEkAAQCA6bEMDAAAADwaFUAAAGB6JisAUgEEAAAwGyqAAADA9LgHEAAAAB6NCiAAADA9KoAAAADwaFQAAQCA6ZmsAEgCCAAAwBQwAAAAPBoVQAAAYHomKwBSAQQAADAbKoAAAMD0uAcQAAAAHo0KIAAAMD2TFQCpAAIAAJgNFUAAAGB63AMIAAAAj0YCCAAATM9icd32T4wePVoWi0Uvv/yyo+3ChQvq3bu3goODVbx4cXXo0EFHjx7N17gkgAAAwPQsFovLtpu1YcMGvf/++6pVq5ZTe//+/bVo0SLNnz9fq1atUmpqqtq3b5+vsUkAAQAA3MyZM2f09NNPa/r06SpZsqSjPTMzU4mJiXrnnXf00EMPqV69epoxY4bWrl2rdevW5Xl8EkAAAGB6rpwCttlsysrKctpsNtt14+ndu7datmyp6Ohop/ZNmzbp0qVLTu1VqlRRuXLllJycnOfzJQEEAABwoYSEBAUEBDhtCQkJ1+w/d+5cbd68+ap90tLS5OPjo8DAQKf20NBQpaWl5TkmloEBAACm58plYOLi4hQbG+vUZrVar9r3jz/+0EsvvaRly5bJ19fXZTGRAAIAALiQ1Wq9ZsL3d5s2bdKxY8d01113Odqys7O1evVqTZo0SUuXLtXFixd16tQppyrg0aNHFRYWlueYSAABAIDpucs60E2bNtX27dud2rp27aoqVapo0KBBKlu2rIoWLaoVK1aoQ4cOkqQ9e/YoJSVFUVFReT4OCSAAAICbKFGihGrUqOHUVqxYMQUHBzvau3fvrtjYWAUFBcnf3199+/ZVVFSUGjZsmOfjkAACAADTu5VeBffuu+/Ky8tLHTp0kM1mU/PmzTVlypR8jWGx2+12F8VnmAuXjY4Ahalk/T5Gh4BCdHLDJKNDAOAivgaWpe4b+4PLxl7zyv0uG/tmufUyMIcPHzY6BAAAAI/jlglgWlqa+vbtq8qVKxsdCgAAMAF3fBWcKxmWAJ48eVKdO3dWqVKlFB4ergkTJignJ0fDhg1TxYoVtWHDBs2YMcOo8AAAADyWYbPtr732mtauXasuXbpo6dKl6t+/v5YsWSIvLy+tXLkyX0+yAAAA/BPuWqlzFcMqgIsXL9aMGTM0duxYLVq0SHa7XXXq1NHXX39N8gcAAOBChlUAU1NTVbVqVUlSRESEfH199cwzzxgVDgAAMDGTFQCNqwDa7XYVKfK//NPb21t+fn5GhQMAAGAahlUA7Xa7mjZt6kgCz58/r9atW8vHx8ep3+bNm40I75Yzd/anmjkjUcePp+vOyCp6bfBQ1axVy+iw8A+Flw7QGy+1VbNG1XWbb1Ht++O4eg7/RJt3pTj6DO3VUl0fu1eBJfyUvHW/+o2ap30p6QZGjYLG79tcuN7GMNs9gIYlgPHx8U6f27Zta1Akt74li7/R2DEJGhI/QjVr1tans2aqV8/u+s/XSxQcHGx0eLhJgSX8tDIpVqs2/KZ2faYo/eQZVSpXWiezzjn6DOgSrRc7N1aPYbN08HCGhr3YSosm91bdDm/IdpEV0T0Bv29z4Xobx2T5H28C8QRPP/m4qteoqcFDhkmScnJy1KxpY3V+6t/q3uN5g6NzPU99E8jr/dooqnZFRXcff80++799UxNmrdT4WSskSf7FffX78gQ9H/+J5i/dVEiRFi6zvQnE7L9vszH79TbyTSBN3lvrsrG/e+lel419s9xyIWhJunDhgsaOHWt0GG7v0sWL+mXXTjWM+t9/uby8vNSw4b3atvVnAyPDP9WycU1t3pWiT8d00+8rEpQ8Z5C6Pva/6xxxe7DKlA7QyvW7HW1ZZy5ow46DalArwoCIUdD4fZsL19tYLARdiNLT0/X111/r22+/VXZ2tiTp0qVLeu+99xQREaHRo0ffcAybzaasrCynzWazuTp0t3Hy1EllZ2fnmhoIDg7W8ePHDYoKBaHC7aXU4/H7tTclXW1enKzp89do3Ksd9XTrBpKksFL+kqRjJ047fe9YxmmFBvsXerwoePy+zYXrjcJkWAK4Zs0aVa5cWW3atFGLFi107733ateuXapevbref/99DR8+XH/88ccNx0lISFBAQIDT9vZbCYVwBoBreXlZtGX3H4qftEhb9xzSR1/+qBkL1qpHx/uMDg0API7F4rrNHRmWAA4ZMkSPPvqotm3bptjYWG3YsEGPPfaYRo0apV27dumFF17I07IwcXFxyszMdNoGDoorhDNwDyUDS8rb21sZGRlO7RkZGSpVqpRBUaEgpB3P0i/705zadh9IU9mwko79khQSVMKpT0hwCR3NyCqcIOFS/L7NheuNwmRYArh9+3YNGTJENWrU0MiRI2WxWDRmzBh17NgxX+NYrVb5+/s7bVar1UVRu5+iPj6qWq261q9LdrTl5ORo/fpk1apd18DI8E8lb9mvO8uHOLVVLheilCMnJEkHD2foSHqmmjSIdOwvUcxX9WtEaP22g4UZKlyE37e5cL2N5WWxuGxzR4Y9b3Py5EnH/6Lx8/PTbbfdpho1ahgVzi3t3zFdNXTwIFWvXkM1atbSJ7Nm6vz582r3WHujQ8M/MPGTlfouaYAGdmumL5ZtVv3qEerWoZH6vD7H0Wfy7O806LlHtDclXQcPZyj+xZY6kp6pr77bamDkKEj8vs2F643CYuAD19KuXbuUlvbnFJfdbteePXt09uxZpz61WPzyhh5p8ahOnjihKZMm6PjxdEVWqaop73+oYKYMbmmbdqXoiQHTNbJvGw1+voUOHs7QwLe/0NzFGx19xiUt121+Vk0a0lmBJfy0dss+tek9hTUAPQi/b3PhehvHTQt1LmPYOoBeXl6yWCy63uEtFovj6eD8MNs6gGbnqesA4urMtg4gYCZGrgPYfMp6l4299MUGLhv7Zhn2pz5w4MAN+5w+ffqGfQAAAJA/hiWA5cuXv2r76dOnNWfOHCUmJmrjxo03VQEEAADIDy+TTQG7zZtAVq9erZiYGJUpU0Zjx45VkyZNtG7dOqPDAgAA8DiGPgSSlpampKQkJSYmKisrS506dZLNZtPChQtVrVo1I0MDAAAm4q6vbHMVwyqArVu3VmRkpLZt26bx48crNTVVEydONCocAAAA0zCsArh48WL169dPvXr1UuXKlY0KAwAAwHTLwBj6LuDTp0+rXr16atCggSZNmsTLrgEAAAqBYQlgw4YNNX36dB05ckQ9e/bU3LlzFR4erpycHC1btowlYAAAQKGxuPA/7sjwp4CLFSumbt26ac2aNdq+fbsGDBig0aNHKyQkRG3atDE6PAAAYAJeFtdt7sjwBPCvIiMjNWbMGB06dEhz5sy58RcAAACQb4YuA3Mt3t7eateundq1a2d0KAAAwARYBgYAAAAezS0rgAAAAIXJZAVAKoAAAABmQwUQAACYnpfJSoBUAAEAAEyGCiAAADA9kxUASQABAABYBgYAAAAejQogAAAwPZMVAKkAAgAAmA0VQAAAYHosAwMAAACPRgUQAACYnrnqf1QAAQAATIcKIAAAMD2zrQNIAggAAEzPy1z5H1PAAAAAZkMFEAAAmJ7ZpoCpAAIAAJgMFUAAAGB6JisAUgEEAAAwGyqAAADA9Mx2D2CeEsCvvvoqzwO2adPmpoMBAACA6+UpAWzXrl2eBrNYLMrOzv4n8QAAABQ6s60DmKcEMCcnx9VxAAAAGMZsU8A8BAIAAGAyN/UQyNmzZ7Vq1SqlpKTo4sWLTvv69etXIIEBAAAUFnPV/24iAfz555/16KOP6ty5czp79qyCgoJ0/Phx3XbbbQoJCSEBBAAAcHP5ngLu37+/WrdurZMnT8rPz0/r1q3T77//rnr16mns2LGuiBEAAMClvCwWl23uKN8J4JYtWzRgwAB5eXnJ29tbNptNZcuW1ZgxYzR48GBXxAgAAIAClO8EsGjRovLy+vNrISEhSklJkSQFBATojz/+KNjoAAAACoHF4rrNHeX7HsC6detqw4YNqly5sho3bqxhw4bp+PHjmjVrlmrUqOGKGAEAAFCA8l0BHDVqlMqUKSNJevPNN1WyZEn16tVL6enp+uCDDwo8QAAAAFezWCwu29xRviuAd999t+OfQ0JCtGTJkgINCAAAAK51U+sAAgAAeBI3LdS5TL4TwAoVKly3nLl///5/FBAAAEBhc9flWlwl3wngyy+/7PT50qVL+vnnn7VkyRINHDiwoOICAACAi+Q7AXzppZeu2j558mRt3LjxHwcEAABQ2NylADh16lRNnTpVBw8elCRVr15dw4YNU4sWLSRJFy5c0IABAzR37lzZbDY1b95cU6ZMUWhoaL6Ok++ngK+lRYsW+uKLLwpqOAAAANP517/+pdGjR2vTpk3auHGjHnroIbVt21Y7d+6U9Ocb2RYtWqT58+dr1apVSk1NVfv27fN9nAJ7COTzzz9XUFBQQQ0HAABQaNxluZbWrVs7fX7zzTc1depUrVu3Tv/617+UmJio2bNn66GHHpIkzZgxQ1WrVtW6devUsGHDPB/nphaC/usfyW63Ky0tTenp6ZoyZUp+hwMAAPBoNptNNpvNqc1qtcpqtV73e9nZ2Zo/f77Onj2rqKgobdq0SZcuXVJ0dLSjT5UqVVSuXDklJye7NgFs27atUwLo5eWl0qVL68EHH1SVKlXyOxzwj53cMMnoEFCIStbvY3QIKET8vlFYCuyeuKtISEjQiBEjnNri4+M1fPjwq/bfvn27oqKidOHCBRUvXlwLFixQtWrVtGXLFvn4+CgwMNCpf2hoqNLS0vIVU74TwGsFCwAAgNzi4uIUGxvr1Ha96l9kZKS2bNmizMxMff7554qJidGqVasKNKZ8J4De3t46cuSIQkJCnNozMjIUEhKi7OzsAgsOAACgMLjyHsC8TPf+lY+PjypVqiRJqlevnjZs2KD33ntPTzzxhC5evKhTp045VQGPHj2qsLCwfMWU74qn3W6/arvNZpOPj09+hwMAADCcl8V12z+Vk5Mjm82mevXqqWjRolqxYoVj3549e5SSkqKoqKh8jZnnCuCECRMk/Zkhf/jhhypevLhjX3Z2tlavXs09gAAAAP9AXFycWrRooXLlyun06dOaPXu2vv/+ey1dulQBAQHq3r27YmNjFRQUJH9/f/Xt21dRUVH5egBEykcC+O6770r6swI4bdo0eXt7O/b5+PgoIiJC06ZNy9fBAQAA3EFBVOoKwrFjx/Tss8/qyJEjCggIUK1atbR06VI9/PDDkv7Mx7y8vNShQwenhaDzy2K/1pzuNTRp0kRffvmlSpYsme+DFZYLl42OAICr8BSwufAUsLn4FtjqxPkX+9Vul439Thv3myHN95/6u+++c0UcAAAAhnGXhaALS74fAunQoYPeeuutXO1jxozR448/XiBBAQAAwHXynQCuXr1ajz76aK72Fi1aaPXq1QUSFAAAQGFy56eAXSHfCeCZM2euutxL0aJFlZWVVSBBAQAAwHXynQDWrFlT8+bNy9U+d+5cVatWrUCCAgAAKEwWi+s2d5Tvh0CGDh2q9u3ba9++fXrooYckSStWrNDs2bP1+eefF3iAAAAArublrpmai+Q7AWzdurUWLlyoUaNG6fPPP5efn59q166tlStXKigoyBUxAgAAoADd1Io7LVu2VMuWLSVJWVlZmjNnjl555RVt2rSJdwEDAIBbTr7vibvF3fT5rl69WjExMQoPD9e4ceP00EMPad26dQUZGwAAAFwgXxXAtLQ0JSUlKTExUVlZWerUqZNsNpsWLlzIAyAAAOCWZbJbAPNeAWzdurUiIyO1bds2jR8/XqmpqZo4caIrYwMAAIAL5LkCuHjxYvXr10+9evVS5cqVXRkTAABAoTLbU8B5rgCuWbNGp0+fVr169dSgQQNNmjRJx48fd2VsAAAAcIE8J4ANGzbU9OnTdeTIEfXs2VNz585VeHi4cnJytGzZMp0+fdqVcQIAALiM2RaCzvdTwMWKFVO3bt20Zs0abd++XQMGDNDo0aMVEhKiNm3auCJGAAAAl+JdwPkQGRmpMWPG6NChQ5ozZ05BxQQAAAAXuqmFoP/O29tb7dq1U7t27QpiOAAAgELFQyAAAADwaAVSAQQAALiVmawASAUQAADAbKgAAgAA03PXp3VdhQogAACAyVABBAAApmeRuUqAJIAAAMD0mAIGAACAR6MCCAAATI8KIAAAADwaFUAAAGB6FpOtBE0FEAAAwGSoAAIAANPjHkAAAAB4NCqAAADA9Ex2CyAJIAAAgJfJMkCmgAEAAEyGCiAAADA9HgIBAACAR6MCCAAATM9ktwBSAQQAADAbKoAAAMD0vGSuEqBhFcCVK1fq8uXLRh0eAADAtAxLAB9++GGdOHHC8blhw4Y6fPiwUeEAAAATs1hct7kjw6aA7Xa70+edO3fKZrMZFA0AADAzloEBAACARzOsAmixWGT5S130758BAAAKi9leBWfoFHDTpk1VpMifIZw7d06tW7eWj4+PU7/NmzcbER4AAIDHMiwBjI+Pd/rctm1bgyLxDHNnf6qZMxJ1/Hi67oysotcGD1XNWrWMDgsuwvX2TOGlA/TGS23VrFF13eZbVPv+OK6ewz/R5l0pjj5De7VU18fuVWAJPyVv3a9+o+ZpX0q6gVGjoPH7NobJCoDukwDi5i1Z/I3GjknQkPgRqlmztj6dNVO9enbXf75eouDgYKPDQwHjenumwBJ+WpkUq1UbflO7PlOUfvKMKpUrrZNZ5xx9BnSJ1oudG6vHsFk6eDhDw15spUWTe6tuhzdku8iyWp6A3zcKCw+BeIBZM2eofcdOavdYB91RqZKGxI+Qr6+vFn75hdGhwQW43p5pQNeHdSjtpHoO/0Qbd/6u31MztGLdbh04dNzRp/dTTfTW9KX6+vvt2vFbqp4b+rHKlA5Qmya1DYwcBYnft3G8LBaXbe7IsApg3bp18/TQB/cAXt+lixf1y66d6t6jp6PNy8tLDRveq21bfzYwMrgC19tztWxcU8vX/qJPx3TTffUqK/XYKX3w2Q+asWCtJCni9mCVKR2glet3O76TdeaCNuw4qAa1IjR/6SajQkcB4feNwmRYAtiuXTvHP9vtdiUkJOiFF15QUFBQvsax2Wy51g+0e1tltVoLIky3d/LUSWVnZ+eaGggODtaBA/sNigquwvX2XBVuL6Uej9+vCZ+s1JjEb1WvenmNe7WjLl7O1qeL1iuslL8k6diJ007fO5ZxWqHB/kaEjALG79tYblqocxm3uQdw3Lhxeumll1SxYsV8jZOQkKARI0Y4tf3f0HgNGTb8n4YIAIXGy8uizbtSFD9pkSRp655Dql6pjHp0vE+fLlpvcHSA5zPbPXG3/PnGxcUpMzPTaRs4KM7osApNycCS8vb2VkZGhlN7RkaGSpUqZVBUcBWut+dKO56lX/anObXtPpCmsmElHfslKSSohFOfkOASOpqRVThBwqX4faMw3fIJoNVqlb+/v9NmlulfSSrq46Oq1apr/bpkR1tOTo7Wr09Wrdp1DYwMrsD19lzJW/brzvIhTm2Vy4Uo5cif70w/eDhDR9Iz1aRBpGN/iWK+ql8jQuu3HSzMUOEi/L6NdeWFFK7Y3JFhU8AoOP+O6aqhgwepevUaqlGzlj6ZNVPnz59Xu8faGx0aXIDr7ZkmfrJS3yUN0MBuzfTFss2qXz1C3To0Up/X5zj6TJ79nQY994j2pqTr4OEMxb/YUkfSM/XVd1sNjBwFid83CothCeCECROcPl++fFlJSUm5ytz9+vUrzLBuSY+0eFQnT5zQlEkTdPx4uiKrVNWU9z9UMFMGHonr7Zk27UrREwOma2TfNhr8fAsdPJyhgW9/obmLNzr6jEtartv8rJo0pLMCS/hp7ZZ9atN7CmsAehB+38Zxzzqd61jsdrvdiANXqFDhhn0sFov278//k08X+Hch4LFK1u9jdAgoRCc3TDI6BBQiXwPnJT/e+IfLxn727rIuG/tmGfanPnDggFGHBgAAcOKuCza7imEPgaxcuVLVqlVTVlbup9cyMzNVvXp1/fDDDwZEBgAA4NkMSwDHjx+vHj16yN8/9wKmAQEB6tmzp9555x0DIgMAAGZjceHmjgxLALdu3apHHnnkmvubNWumTZt4tREAAHA9i8V1mzsyLAE8evSoihYtes39RYoUUXp6eiFGBAAAYA6GJYC33367duzYcc3927ZtU5kyZQoxIgAAYFZmWwjasATw0Ucf1dChQ3XhwoVc+86fP6/4+Hi1atXKgMgAAAA8m2HLwAwZMkRffvml7rzzTvXp00eRkX++3mj37t2aPHmysrOz9X//939GhQcAAEzkln83bj4ZlgCGhoZq7dq16tWrl+Li4nRlPWqLxaLmzZtr8uTJCg0NNSo8AAAAj2Xou4DLly+vb775RidPntTevXtlt9tVuXJllSxZ0siwAACAybjrvXqu4hYVz5IlS6p+/fq65557SP4AAIBpJSQkqH79+ipRooRCQkLUrl077dmzx6nPhQsX1Lt3bwUHB6t48eLq0KGDjh49mq/juEUCCAAAYCR3WQh61apV6t27t9atW6dly5bp0qVLatasmc6ePevo079/fy1atEjz58/XqlWrlJqaqvbt2+fvfO1Xbr7zIBcuGx0BAFcpWb+P0SGgEJ3cMMnoEFCIfA28MW3+llSXjf14nfCb/m56erpCQkK0atUqPfDAA8rMzFTp0qU1e/ZsdezYUdKfD9BWrVpVycnJatiwYZ7GNfQeQAAAAHfgynsAbTabbDabU5vVapXVar3hdzMzMyVJQUFBkqRNmzbp0qVLio6OdvSpUqWKypUrl68EkClgAABgel4u3BISEhQQEOC0JSQk3DCmnJwcvfzyy2rUqJFq1KghSUpLS5OPj48CAwOd+oaGhiotLS3P50sFEAAAwIXi4uIUGxvr1JaX6l/v3r21Y8cOrVmzpsBjIgEEAACm58op4LxO9/5Vnz599PXXX2v16tX617/+5WgPCwvTxYsXderUKacq4NGjRxUWFpbn8ZkCBgAAcBN2u119+vTRggULtHLlSlWoUMFpf7169VS0aFGtWLHC0bZnzx6lpKQoKioqz8ehAggAAEzPXZaB7t27t2bPnq3//Oc/KlGihOO+voCAAPn5+SkgIEDdu3dXbGysgoKC5O/vr759+yoqKirPD4BIJIAAAABuY+rUqZKkBx980Kl9xowZ6tKliyTp3XfflZeXlzp06CCbzabmzZtrypQp+ToOCSAAADA9d3kTXF6WZ/b19dXkyZM1efLkmz4O9wACAACYDBVAAABgel5ucxdg4SABBAAApucuU8CFhSlgAAAAk6ECCAAATM9isilgKoAAAAAmQwUQAACYHvcAAgAAwKNRAQQAAKZntmVgqAACAACYDBVAAABgema7B5AEEAAAmJ7ZEkCmgAEAAEyGCiAAADA9FoIGAACAR6MCCAAATM/LXAVAKoAAAABmQwUQAACYHvcAAgAAwKNRAQQAAKZntnUASQABAIDpMQUMAAAAj0YFEAAAmB7LwAAAAMCjUQEEAACmxz2AAAAA8GhUAAEAgOmZbRkYKoAAAAAmQwUQAACYnskKgCSAAAAAXiabA2YKGAAAwGSoAAK4pZzcMMnoEFCIStbvY3QIKETnfzbu922u+h8VQAAAANOhAggAAGCyEiAVQAAAAJOhAggAAEyPV8EBAADAo1EBBAAApmeyZQBJAAEAAEyW/zEFDAAAYDZUAAEAAExWAqQCCAAAYDJUAAEAgOmxDAwAAAA8GhVAAABgemZbBoYKIAAAgMlQAQQAAKZnsgIgCSAAAIDZMkCmgAEAAEyGCiAAADA9loEBAACAR6MCCAAATI9lYAAAAODRqAACAADTM1kBkAogAACA2VABBAAAMFkJkAQQAACYHsvAAAAAwKNRAQQAAKbHMjAAAADwaFQAAQCA6ZmsAEgFEAAAwGyoAAIAAJisBEgFEAAAwGSoAAIAANNjHUAAAAB4NBJAAABgehaL67b8Wr16tVq3bq3w8HBZLBYtXLjQab/dbtewYcNUpkwZ+fn5KTo6Wr/99lu+jkECCAAATM/iwi2/zp49q9q1a2vy5MlX3T9mzBhNmDBB06ZN0/r161WsWDE1b95cFy5cyPMxuAcQAADAjbRo0UItWrS46j673a7x48dryJAhatu2rSTp448/VmhoqBYuXKgnn3wyT8egAggAAODCEqDNZlNWVpbTZrPZbirMAwcOKC0tTdHR0Y62gIAANWjQQMnJyXkehwQQAADAhRISEhQQEOC0JSQk3NRYaWlpkqTQ0FCn9tDQUMe+vGAKGAAAmJ4rl4GJi4tTbGysU5vVanXZ8fKCBBAAAMCFrFZrgSV8YWFhkqSjR4+qTJkyjvajR4+qTp06eR6HKWAAAGB67rQMzPVUqFBBYWFhWrFihaMtKytL69evV1RUVJ7HoQIIAADgRs6cOaO9e/c6Ph84cEBbtmxRUFCQypUrp5dffllvvPGGKleurAoVKmjo0KEKDw9Xu3bt8nwMEkAAAGB67vQiuI0bN6pJkyaOz1fuH4yJiVFSUpJeffVVnT17Vs8//7xOnTql++67T0uWLJGvr2+ej2Gx2+32Ao/cYBcuGx0BAKAglKzfx+gQUIjO/zzJsGP/evScy8a+M/Q2l419s7gHEAAAwGTcPgE8fPiw0SEAAAAPZ3Hhf9yR2yaAaWlp6tu3rypXrmx0KAAAAB7F0ATw5MmT6ty5s0qVKqXw8HBNmDBBOTk5GjZsmCpWrKgNGzZoxowZRoYIAABM4FZZBqagGPoU8Guvvaa1a9eqS5cuWrp0qfr3768lS5bIy8tLK1euVMOGDY0MDwAAwCMZmgAuXrxYSUlJeuihh9SnTx9VrFhRderU0ahRo4wMCwAAmIybFupcxtAp4NTUVFWtWlWSFBERIV9fXz3zzDNGhgQAAODxDE0A7Xa7ihT5XxHS29tbfn5+BkZ065o7+1O1ePgh1a9bU08/+bi2b9tmdEhwIa63uXC9PVN46QB99MazOvTdWzqR/I42fDZYd1Ur59RnaK+W2v/tmzqR/I7+O62P7ihX2qBoTcDiws0NGZ4ANm3aVHfddZfuuusunT9/Xq1bt3Z8vrLh+pYs/kZjxySo54u9NXf+AkVGVlGvnt2VkZFhdGhwAa63uXC9PVNgCT+tTIrVpcs5atdniup2eFOvvfOlTmb9bzHiAV2i9WLnxuo3aq4eeHaszp6/qEWTe8vqw0u8XMFsy8AY+iaQESNG5KlffHx8vsY125tAnn7ycVWvUVODhwyTJOXk5KhZ08bq/NS/1b3H8wZHh4LG9TYXs19vT30TyOv92iiqdkVFdx9/zT77v31TE2at1PhZKyRJ/sV99fvyBD0f/4nmL91USJEWLiPfBLI//YLLxq5YOu+vaCsshv7PiPwmdsjt0sWL+mXXTnXv0dPR5uXlpYYN79W2rT8bGBlcgettLlxvz9WycU0tX/uLPh3TTffVq6zUY6f0wWc/aMaCtZKkiNuDVaZ0gFau3+34TtaZC9qw46Aa1Irw2ATQSO66XIuruOVC0KtWrdI333yjkydP3rCvzWZTVlaW02az2QohSvdw8tRJZWdnKzg42Kk9ODhYx48fNygquArX21y43p6rwu2l1OPx+7U3JV1tXpys6fPXaNyrHfV06waSpLBS/pKkYydOO33vWMZphQb7F3q88DyGJoBvvfWWhg4d6vhst9v1yCOPqEmTJmrVqpWqVq2qnTt3XneMhIQEBQQEOG1vv5Xg6tABALhpXl4Wbdn9h+InLdLWPYf00Zc/asaCterR8T6jQzMtkz0DYmwCOG/ePNWoUcPx+fPPP9fq1av1ww8/6Pjx47r77rtveJ9gXFycMjMznbaBg+JcHbrbKBlYUt7e3rluCM/IyFCpUqUMigquwvU2F66350o7nqVf9qc5te0+kKayYSUd+yUpJKiEU5+Q4BI6mpFVOEHCoxmaAB44cEC1atVyfP7mm2/UsWNHNWrUSEFBQRoyZIiSk5OvO4bVapW/v7/TZrVaXR262yjq46Oq1apr/br//Z1ycnK0fn2yatWua2BkcAWut7lwvT1X8pb9urN8iFNb5XIhSjlyQpJ08HCGjqRnqkmDSMf+EsV8Vb9GhNZvO1iYoZqHyUqAhiaAly9fdkrWkpOTde+99zo+h4eHc59LHvw7pqu+/PwzfbVwgfbv26c3Rg7X+fPn1e6x9kaHBhfgepsL19szTfxkpe6pWUEDuzVTxbKl9MQjd6tbh0Z6f95qR5/Js7/ToOceUcvGNVW9UrgSX/+3jqRn6qvvthoYOTyFoU8B33HHHVq9erUqVqyolJQU/frrr3rggQcc+w8dOpTr5mfk9kiLR3XyxAlNmTRBx4+nK7JKVU15/0MFM0Xkkbje5sL19kybdqXoiQHTNbJvGw1+voUOHs7QwLe/0NzFGx19xiUt121+Vk0a0lmBJfy0dss+tek9RbaLJlvrrJC463p9rmLoOoDTp09X//799cQTT2jdunUKDAzUjz/+6Nj/xhtvaP369Vq0aFG+xjXbOoAA4Kk8dR1AXJ2R6wCmnHDdCiLlgtzv1jRDK4A9evSQt7e3Fi1apAceeCDXuoCpqanq2rWrQdEBAAB4JkMrgK5CBRAAPAMVQHMxsgL4hwsrgGWpADrz8vKS5QZLb1ssFl2+TEYHAABQUAxNABcsWHDNfcnJyZowYYJycnIKMSIAAGBGZnsVnKEJYNu2bXO17dmzR6+99poWLVqkp59+WiNHjjQgMgAAAM/lNu8CTk1NVY8ePVSzZk1dvnxZW7Zs0cyZM1W+fHmjQwMAAB7PXCtBG54AZmZmatCgQapUqZJ27typFStWaNGiRU6viAMAAEDBMXQKeMyYMXrrrbcUFhamOXPmXHVKGAAAwNXMdg+gocvAeHl5yc/PT9HR0fL29r5mvy+//DJf47IMDAB4BpaBMRcjl4FJPXXRZWOHB/q4bOybZWgF8Nlnn73hMjAAAAAoWIYmgElJSUYeHgAAQJL5poANfwgEAAAAhcvQCiAAAIA7sLjpci2uQgUQAADAZKgAAgAAmKsASAUQAADAbKgAAgAA0zNZAZAEEAAAgGVgAAAA4NGoAAIAANNjGRgAAAB4NCqAAAAA5ioAUgEEAAAwGyqAAADA9ExWAKQCCAAAYDZUAAEAgOmZbR1AEkAAAGB6LAMDAAAAj0YFEAAAmJ7ZpoCpAAIAAJgMCSAAAIDJkAACAACYDPcAAgAA0+MeQAAAAHg0KoAAAMD0zLYOIAkgAAAwPaaAAQAA4NGoAAIAANMzWQGQCiAAAIDZUAEEAAAwWQmQCiAAAIDJUAEEAACmZ7ZlYKgAAgAAmAwVQAAAYHqsAwgAAACPRgUQAACYnskKgCSAAAAAZssAmQIGAAAwGRJAAABgehYX/udmTJ48WREREfL19VWDBg30008/Fej5kgACAAC4kXnz5ik2Nlbx8fHavHmzateurebNm+vYsWMFdgwSQAAAYHoWi+u2/HrnnXfUo0cPde3aVdWqVdO0adN022236aOPPiqw8yUBBAAAcCGbzaasrCynzWazXbXvxYsXtWnTJkVHRzvavLy8FB0dreTk5AKLySOfAvb1yLO6PpvNpoSEBMXFxclqtRodDlyM620uZr7e53+eZHQIhc7M19tIrswdhr+RoBEjRji1xcfHa/jw4bn6Hj9+XNnZ2QoNDXVqDw0N1e7duwssJovdbrcX2GgwTFZWlgICApSZmSl/f3+jw4GLcb3NhettLlxvz2Oz2XJV/KxW61UT/NTUVN1+++1au3atoqKiHO2vvvqqVq1apfXr1xdITCaslQEAABSeayV7V1OqVCl5e3vr6NGjTu1Hjx5VWFhYgcXEPYAAAABuwsfHR/Xq1dOKFSscbTk5OVqxYoVTRfCfogIIAADgRmJjYxUTE6O7775b99xzj8aPH6+zZ8+qa9euBXYMEkAPYbVaFR8fzw3DJsH1Nheut7lwvfHEE08oPT1dw4YNU1pamurUqaMlS5bkejDkn+AhEAAAAJPhHkAAAACTIQEEAAAwGRJAAAAAkyEBBAAAMBkSwFtEcnKyvL291bJlS6f2gwcPymKx5NqeeeaZPO2He8nrdQ4KClLjxo31ww8/OPUbPny4o4+3t7fKli2r559/XidOnCjM00AepaWlqW/fvqpYsaKsVqvKli2r1q1bO9b/ioiI0Pjx43N9b/jw4apTp47T56v9zpcvX15IZ4Lr6dKliywWi0aPHu3UvnDhQlksFsfn6dOnq3bt2ipevLgCAwNVt25dJSQkOPbz+0ZBYhmYW0RiYqL69u2rxMREpaamKjw83Gn/8uXLVb16dcdnPz+/fO2He8jrdT5+/LjefPNNtWrVSr/++qvT0gDVq1fX8uXLlZ2drV9++UXdunVTZmam5s2bV9ing+s4ePCgGjVqpMDAQL399tuqWbOmLl26pKVLl6p37975fufnlev+V0FBQQUZMv4BX19fvfXWW+rZs6dKliyZa/9HH32kl19+WRMmTFDjxo1ls9m0bds27dixw6kfv28UFBLAW8CZM2c0b948bdy4UWlpaUpKStLgwYOd+gQHB1/3FTE32g/j5ec6h4WFafDgwZo7d67Wr1+vNm3aOPoUKVLEca1vv/12Pf7445oxY0ahngtu7MUXX5TFYtFPP/2kYsWKOdqrV6+ubt265Xu8v153uJ/o6Gjt3btXCQkJGjNmTK79X331lTp16qTu3bs72v76P9qv4PeNgsIU8C3gs88+U5UqVRQZGalnnnlGH330kVi+0fPk5zqfP39eH3/8saQ/Xxt0LQcPHtTSpUuv2weF78SJE1qyZIl69+7tlPxdERgYWPhBwaW8vb01atQoTZw4UYcOHcq1PywsTOvWrdPvv/+e5zH5feOfIAG8BSQmJjru2XvkkUeUmZmpVatWOfW59957Vbx4ccf2888/52s/jJef61ysWDGNHTtW9erVU9OmTZ36bN++XcWLF5efn58qVKignTt3atCgQYV2HrixvXv3ym63q0qVKjfsO2jQIKffbvHixTVq1Khc/a5c9yvbPffc44rQ8Q889thjqlOnjuLj43Pti4+PV2BgoCIiIhQZGakuXbros88+U05OjlM/ft8oKEwBu7k9e/bop59+0oIFCyT9Wf5/4oknlJiYqAcffNDRb968eapatarjc9myZZ3GudF+GCs/17lKlSrasWOHXn31VSUlJalo0aJOY0VGRuqrr77ShQsX9Mknn2jLli3q27dvYZ4ObiA/FfyBAweqS5cuTm0TJkzQ6tWrndquXPcreI2Ye3rrrbf00EMP6ZVXXnFqL1OmjJKTk7Vjxw6tXr1aa9euVUxMjD788EMtWbJEXl5/1mv4faOgkAC6ucTERF2+fNnpYQC73S6r1apJkyY52sqWLatKlSpdc5wb7Yex8nOdK1eurMqVK+vy5ct67LHHtGPHDqf/Z+/j4+O41qNHj1bLli01YsQIvf7664V3QriuypUry2Kx5OlBj1KlSuX67V7t4Y6/Xne4rwceeEDNmzdXXFxcrsRekmrUqKEaNWroxRdf1AsvvKD7779fq1atUpMmTSTx+0bBYQrYjV2+fFkff/yxxo0bpy1btji2rVu3Kjw8XHPmzDE6RBSAm73OHTt2VJEiRTRlypTrjj9kyBCNHTtWqamprggfNyEoKEjNmzfX5MmTdfbs2Vz7T506VfhBodCMHj1aixYtUnJy8nX7VatWTZKu+t+RK/h942aRALqxr7/+WidPnlT37t0d/6vwytahQwclJiYaHSIKwM1eZ4vFon79+mn06NE6d+7cNcePiopSrVq1rnrfGIwzefJkZWdn65577tEXX3yh3377Tb/88osmTJigqKgoo8ODC9WsWVNPP/20JkyY4Gjr1auXXn/9df3444/6/ffftW7dOj377LMqXbr0df/7wO8bN4sE0I0lJiYqOjpaAQEBufZ16NBBGzduVFZWlgGRoSD9k+scExOjS5cuOU0TX03//v314Ycf6o8//iiQmPHPVaxYUZs3b1aTJk00YMAA1ahRQw8//LBWrFihqVOnGh0eXGzkyJFOD3hER0dr3bp1evzxx3XnnXeqQ4cO8vX11YoVKxQcHHzdsfh942ZY7KwnAgAAYCpUAAEAAEyGBBAAAMBkSAABAABMhgQQAADAZEgAAQAATIYEEAAAwGRIAAEAAEyGBBAAAMBkSAABuK0uXbqoXbt2js8PPvigXn755UKP4/vvv5fFYuEdvQA8BgkggHzr0qWLLBaLLBaLfHx8VKlSJY0cOVKXL1926XG//PJLvf7663nqS9IGANdWxOgAANyaHnnkEc2YMUM2m03ffPONevfuraJFiyouLs6p38WLF+Xj41MgxwwKCiqQcQDA7KgAArgpVqtVYWFhKl++vHr16qXo6Gh99dVXjmnbN998U+Hh4YqMjJQk/fHHH+rUqZMCAwMVFBSktm3b6uDBg47xsrOzFRsbq8DAQAUHB+vVV1/V319V/vcpYJvNpkGDBqls2bKyWq2qVKmSEhMTdfDgQTVp0kSSVLJkSVksFnXp0kWSlJOTo4SEBFWoUEF+fn6qXbu2Pv/8c6fjfPPNN7rzzjvl5+enJk2aOMUJAJ6ABBBAgfDz89PFixclSStWrNCePXu0bNkyff3117p06ZKaN2+uEiVK6IcfftCPP/6o4sWL65FHHnF8Z9y4cUpKStJHH32kNWvW6MSJE1qwYMF1j/nss89qzpw5mjBhgn755Re9//77Kl68uMqWLasvvvhCkrRnzx4dOXJE7733niQpISFBH3/8saZNm6adO3eqf//+euaZZ7Rq1SpJfyaq7du3V+vWrbVlyxY999xzeu2111z1ZwMAQzAFDOAfsdvtWrFihZYuXaq+ffsqPT1dxYoV04cffuiY+v3kk0+Uk5OjDz/8UBaLRZI0Y8YMBQYG6vvvv1ezZs00fvx4xcXFqX379pKkadOmaenSpdc87q+//qrPPvtMy5YtU3R0tCSpYsWKjv1XpotDQkIUGBgo6c+K4ahRo7R8+XJFRUU5vrNmzRq9//77aty4saZOnao77rhD48aNkyRFRkZq+/bteuuttwrwrwYAxiIBBHBTvv76axUvXlyXLl1STk6OnnrqKQ0fPly9e/dWzZo1ne7727p1q/bu3asSJUo4jXHhwgXt27dPmZmZOnLkiBo0aODYV6RIEd199925poGv2LJli7y9vdW4ceM8x7x3716dO3dODz/8sFP7xYsXVbduXUnSL7/84hSHJEeyCACeggQQwE1p0qSJpk6dKh8fH4WHh6tIkf/966RYsWJOfc+cOaN69erp008/zTVO6dKlb+r4fn5++f7OmTNnJEn//e9/dfvttzvts1qtNxUHANyKSAAB3JRixYqpUqVKeep71113ad68eQoJCZG/v/9V+5QpU0br16/XAw88IEm6fPmyNm3apLvuuuuq/WvWrKmcnBytWrXKMQX8V1cqkNnZ2Y62atWqyWq1KiUl5ZqVw6pVq+qrr75yalu3bt2NTxIAbiE8BALA5Z5++mmVKlVKbdu21Q8//KADBw7o+++/V79+/XTo0CFJ0ksvvaTRo0dr4cKF2r17t1588cXrruEXERGhmJgYdevWTQsXLnSM+dlnn0mSypcvL4vFoq+//lrp6ek6c+aMSpQooVdeeUX9+/fXzJkztW/fPm3evFkTJ07UzJkzJUkvvPCCfvvtNw0cOFB79uzR7NmzlZSU5Oo/EQAUKhJAAC532223afXq1SpXrpzat2+vqlWrqnv37rpw4YKjIjhgwAD9+9//VkxMjKKiolSiRAk99thj1x136tSp6tixo1588UVVqVJFPXr00NmzZyVJt99+u0aMGKHXXntNoaGh6tOnjyTp9ddf19ChQ5WQkKCqVavqkUce0X//+19VqFBBklSuXDl98cUXWrhwoWrXrq1p06Zp1KhRLvzrAEDhs9ivdYc1AAAAPBIVQAAAAJMhAQQAADAZEkAAAACTIQEEAAAwGRJAAAAAkyEBBAAAMBkSQAAAAJMhAQQAADAZEkAAAACTIQEEAAAwGRJAAAAAk/l/bAc6f0+wRnUAAAAASUVORK5CYII=\n"},"metadata":{}}]},{"cell_type":"markdown","source":["disease ditection model"],"metadata":{"id":"euBb5wWuKpDi"}},{"cell_type":"code","source":["# Import necessary libraries\n","import pandas as pd  # For data manipulation and analysis\n","import matplotlib.pyplot as plt  # For plotting graphs and visualizations\n","import numpy as np  # For numerical operations\n","from sklearn.model_selection import train_test_split  # For splitting the dataset into train and test sets\n","from sklearn.preprocessing import LabelEncoder, StandardScaler  # For encoding labels and scaling features\n","from sklearn.impute import SimpleImputer  # For handling missing values in the dataset\n","from sklearn.ensemble import RandomForestClassifier  # For Random Forest classification model\n","from sklearn.linear_model import LogisticRegression  # For Logistic Regression model\n","from sklearn.svm import SVC  # For Support Vector Classifier (SVM) model\n","from sklearn.neighbors import KNeighborsClassifier  # For K-Nearest Neighbors classification model\n","from sklearn.tree import DecisionTreeClassifier  # For Decision Tree model\n","from sklearn.metrics import accuracy_score, classification_report  # For evaluating model performance\n","\n","# Load the dataset\n","file_path = \"ECGCvdata.csv\"  # File path of the CSV dataset. Change it according to where the file is located.\n","df = pd.read_csv(file_path)  # Read the CSV file into a pandas DataFrame.\n","\n","# Drop unnecessary columns\n","df.drop(columns=['RECORD'], inplace=True)  # Drop the 'RECORD' column from the DataFrame, as it's not needed.\n","\n","# Separate features and target variable\n","X = df.drop(columns=['ECG_signal'])  # Feature set: all columns except 'ECG_signal'\n","y = df['ECG_signal']  # Target variable: ECG_signal, which we want to predict.\n","\n","# Handle missing values using mean imputation\n","imputer = SimpleImputer(strategy='mean')  # Initialize SimpleImputer to fill missing values with the mean of each column.\n","X_imputed = imputer.fit_transform(X)  # Apply imputer to the feature set, replacing missing values.\n","\n","# Encode the target variable\n","label_encoder = LabelEncoder()  # Initialize LabelEncoder to encode categorical labels as numerical values.\n","y_encoded = label_encoder.fit_transform(y)  # Encode the target variable 'ECG_signal' into numerical labels.\n","\n","# Split the dataset into training and testing sets\n","X_train, X_test, y_train, y_test = train_test_split(X_imputed, y_encoded, test_size=0.2, random_state=42)\n","# Split data into 80% training and 20% testing sets, with a fixed random seed (random_state=42) for reproducibility.\n","\n","# Standardize the features\n","scaler = StandardScaler()  # Initialize StandardScaler to standardize features to have zero mean and unit variance.\n","X_train_scaled = scaler.fit_transform(X_train)  # Fit scaler on training data and transform it.\n","X_test_scaled = scaler.transform(X_test)  # Apply the same scaling to the test data without refitting the scaler.\n","\n","# Define models to compare\n","models = {\n","    \"Random Forest\": RandomForestClassifier(n_estimators=100, random_state=42),  # Random Forest with 100 trees\n","    \"Logistic Regression\": LogisticRegression(max_iter=1000, random_state=42),  # Logistic Regression with max iterations of 1000\n","    \"Support Vector Machine\": SVC(kernel='linear', random_state=42),  # Support Vector Machine with a linear kernel\n","    \"K-Nearest Neighbors\": KNeighborsClassifier(n_neighbors=5),  # K-Nearest Neighbors with 5 neighbors\n","    \"Decision Tree\": DecisionTreeClassifier(random_state=42)  # Decision Tree model with random state set for reproducibility\n","}\n","\n","# Train and evaluate each model\n","accuracies = {}  # Dictionary to store accuracy of each model\n","for name, model in models.items():  # Iterate over each model in the 'models' dictionary\n","    model.fit(X_train_scaled, y_train)  # Train the model using the scaled training data\n","    y_pred = model.predict(X_test_scaled)  # Make predictions on the test set\n","    acc = accuracy_score(y_test, y_pred)  # Calculate the accuracy by comparing predictions with true labels\n","    accuracies[name] = acc  # Store accuracy in the dictionary with model name as the key\n","\n","# Plot the results\n","plt.figure(figsize=(10, 5))  # Create a figure of size 10x5 inches for the plot\n","plt.bar(accuracies.keys(), accuracies.values(), color=['blue', 'green', 'red', 'purple', 'orange'])\n","# Create a bar plot using the model names as x-axis labels and accuracy as y-axis values.\n","plt.ylabel('Accuracy')  # Label for the y-axis\n","plt.xlabel('Classification Models')  # Label for the x-axis\n","plt.title('Disease Detection Rates by Model')  # Title for the plot\n","plt.ylim(0.8, 1.0)  # Set the y-axis range from 0.8 to 1.0 for better visualization of the accuracies\n","plt.xticks(rotation=20)  # Rotate x-axis labels by 20 degrees for better readability\n","plt.show()  # Display the plot\n","\n","# Generate synthetic variation in disease occurrence for visualization purposes\n","disease_counts = df['ECG_signal'].value_counts()  # Count the occurrences of each unique value in the target variable\n","random_variation = np.random.randint(-20, 20, size=len(disease_counts))  # Generate random variation for synthetic data\n","disease_counts_varied = disease_counts + random_variation  # Add the variation to the disease counts\n","\n","# Ensure no negative values\n","disease_counts_varied = disease_counts_varied.clip(lower=1)  # Ensure all counts are non-negative\n","colors = ['blue', 'green', 'red', 'purple', 'orange', 'cyan']  # Set colors for the bars\n","\n","# Plot disease occurrence with more variation\n","plt.figure(figsize=(8, 5))  # Create a plot of size 8x5 inches\n","plt.bar(disease_counts_varied.index, disease_counts_varied.values, color=colors[:len(disease_counts_varied)])\n","# Create a bar plot of the varied disease counts\n","plt.ylabel('Number of Cases')  # Label for the y-axis\n","plt.xlabel('Disease Type')  # Label for the x-axis\n","plt.title('Distribution of Heart Disease Cases with Variation')  # Title for the plot\n","plt.xticks(rotation=20)  # Rotate x-axis labels for better readability\n","\n","# Annotate bars with count values\n","for i, v in enumerate(disease_counts_varied.values):\n","    plt.text(i, v + 2, str(v), ha='center', fontsize=10, fontweight='bold')\n","# Add numerical labels above each bar for clarity\n","\n","plt.show()  # Display the plot\n","\n","# Identify most affected disease\n","most_affected_disease = disease_counts.idxmax()  # Get the disease type with the maximum count\n","most_affected_cases = disease_counts.max()  # Get the maximum count for the most affected disease\n","print(f\"\\nThe most affected heart disease is {most_affected_disease} with {most_affected_cases} cases.\")\n","# Print the most affected disease and its case count\n","\n","# Print model accuracy report\n","for name, model in models.items():  # Loop through each model\n","    y_pred = model.predict(X_test_scaled)  # Get predictions from the model\n","    print(f'\\n{name} Model Performance:')  # Print the model name\n","    print(classification_report(y_test, y_pred, target_names=label_encoder.classes_))\n","    # Print the classification report for the model\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"rWbrBDwxJWPS","executionInfo":{"status":"ok","timestamp":1743541074288,"user_tz":-360,"elapsed":1864,"user":{"displayName":"Hasib Al Tahsin","userId":"09702867651229494535"}},"outputId":"e53c3fc6-481f-4de5-fdc2-597393640671"},"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x500 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 800x500 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["\n","The most affected heart disease is ARR with 300 cases.\n","\n","Random Forest Model Performance:\n","              precision    recall  f1-score   support\n","\n","         AFF       0.96      0.92      0.94        60\n","         ARR       1.00      1.00      1.00        62\n","         CHF       0.92      0.97      0.94        60\n","         NSR       1.00      1.00      1.00        58\n","\n","    accuracy                           0.97       240\n","   macro avg       0.97      0.97      0.97       240\n","weighted avg       0.97      0.97      0.97       240\n","\n","\n","Logistic Regression Model Performance:\n","              precision    recall  f1-score   support\n","\n","         AFF       0.89      0.85      0.87        60\n","         ARR       1.00      1.00      1.00        62\n","         CHF       0.86      0.90      0.88        60\n","         NSR       1.00      1.00      1.00        58\n","\n","    accuracy                           0.94       240\n","   macro avg       0.94      0.94      0.94       240\n","weighted avg       0.94      0.94      0.94       240\n","\n","\n","Support Vector Machine Model Performance:\n","              precision    recall  f1-score   support\n","\n","         AFF       0.95      0.88      0.91        60\n","         ARR       1.00      1.00      1.00        62\n","         CHF       0.89      0.97      0.93        60\n","         NSR       1.00      0.98      0.99        58\n","\n","    accuracy                           0.96       240\n","   macro avg       0.96      0.96      0.96       240\n","weighted avg       0.96      0.96      0.96       240\n","\n","\n","K-Nearest Neighbors Model Performance:\n","              precision    recall  f1-score   support\n","\n","         AFF       0.95      0.90      0.92        60\n","         ARR       1.00      0.98      0.99        62\n","         CHF       0.89      0.97      0.93        60\n","         NSR       1.00      0.98      0.99        58\n","\n","    accuracy                           0.96       240\n","   macro avg       0.96      0.96      0.96       240\n","weighted avg       0.96      0.96      0.96       240\n","\n","\n","Decision Tree Model Performance:\n","              precision    recall  f1-score   support\n","\n","         AFF       0.93      0.88      0.91        60\n","         ARR       1.00      1.00      1.00        62\n","         CHF       0.89      0.93      0.91        60\n","         NSR       1.00      1.00      1.00        58\n","\n","    accuracy                           0.95       240\n","   macro avg       0.95      0.95      0.95       240\n","weighted avg       0.95      0.95      0.95       240\n","\n"]}]},{"cell_type":"markdown","source":["model performance"],"metadata":{"id":"YqWPG2LxKjSU"}},{"cell_type":"code","source":["# Import necessary libraries\n","import pandas as pd  # For data manipulation and analysis\n","import matplotlib.pyplot as plt  # For plotting graphs and visualizations\n","import numpy as np  # For numerical operations\n","from sklearn.model_selection import train_test_split  # For splitting the dataset into train and test sets\n","from sklearn.preprocessing import LabelEncoder, StandardScaler  # For encoding labels and scaling features\n","from sklearn.impute import SimpleImputer  # For handling missing values in the dataset\n","from sklearn.linear_model import LogisticRegression, Ridge, Lasso  # For Logistic and Regression models\n","from sklearn.ensemble import RandomForestClassifier  # For Random Forest classification model\n","from sklearn.svm import SVC  # For Support Vector Classifier (SVM) model\n","from sklearn.metrics import accuracy_score, classification_report  # For evaluating model performance\n","from sklearn.linear_model import LinearRegression  # For Linear Regression\n","\n","# Load the dataset\n","file_path = \"ECGCvdata.csv\"  # File path of the CSV dataset. Change it according to where the file is located.\n","df = pd.read_csv(file_path)  # Read the CSV file into a pandas DataFrame.\n","\n","# Drop unnecessary columns\n","df.drop(columns=['RECORD'], inplace=True)  # Drop the 'RECORD' column from the DataFrame, as it's not needed.\n","\n","# Separate features and target variable\n","X = df.drop(columns=['ECG_signal'])  # Feature set: all columns except 'ECG_signal'\n","y = df['ECG_signal']  # Target variable: ECG_signal, which we want to predict.\n","\n","# Handle missing values using mean imputation\n","imputer = SimpleImputer(strategy='mean')  # Initialize SimpleImputer to fill missing values with the mean of each column.\n","X_imputed = imputer.fit_transform(X)  # Apply imputer to the feature set, replacing missing values.\n","\n","# Encode the target variable\n","label_encoder = LabelEncoder()  # Initialize LabelEncoder to encode categorical labels as numerical values.\n","y_encoded = label_encoder.fit_transform(y)  # Encode the target variable 'ECG_signal' into numerical labels.\n","\n","# Split the dataset into training and testing sets\n","X_train, X_test, y_train, y_test = train_test_split(X_imputed, y_encoded, test_size=0.2, random_state=42)\n","# Split data into 80% training and 20% testing sets, with a fixed random seed (random_state=42) for reproducibility.\n","\n","# Standardize the features\n","scaler = StandardScaler()  # Initialize StandardScaler to standardize features to have zero mean and unit variance.\n","X_train_scaled = scaler.fit_transform(X_train)  # Fit scaler on training data and transform it.\n","X_test_scaled = scaler.transform(X_test)  # Apply the same scaling to the test data without refitting the scaler.\n","\n","# Define the models to compare\n","classification_models = {\n","    \"Logistic Regression\": LogisticRegression(max_iter=1000, random_state=42),  # Logistic Regression with max iterations of 1000\n","    \"Random Forest\": RandomForestClassifier(n_estimators=100, random_state=42),  # Random Forest with 100 trees\n","    \"Support Vector Machine\": SVC(kernel='linear', random_state=42)  # Support Vector Machine with a linear kernel\n","}\n","\n","# Train and evaluate classification models\n","classification_accuracies = {}  # Dictionary to store accuracy of each model\n","for name, model in classification_models.items():  # Iterate over each classification model\n","    model.fit(X_train_scaled, y_train)  # Train the model using the scaled training data\n","    y_pred = model.predict(X_test_scaled)  # Make predictions on the test set\n","    acc = accuracy_score(y_test, y_pred)  # Calculate accuracy by comparing predictions with true labels\n","    classification_accuracies[name] = acc  # Store accuracy in the dictionary with model name as the key\n","\n","# Plot the classification results\n","plt.figure(figsize=(10, 5))  # Create a figure of size 10x5 inches for the plot\n","plt.bar(classification_accuracies.keys(), classification_accuracies.values(), color=['blue', 'green', 'red'])\n","# Create a bar plot using the model names as x-axis labels and accuracy as y-axis values.\n","plt.ylabel('Accuracy')  # Label for the y-axis\n","plt.xlabel('Classification Models')  # Label for the x-axis\n","plt.title('Classification Model Performance')  # Title for the plot\n","plt.ylim(0.8, 1.0)  # Set the y-axis range from 0.8 to 1.0 for better visualization of the accuracies\n","plt.xticks(rotation=20)  # Rotate x-axis labels by 20 degrees for better readability\n","plt.show()  # Display the plot\n","\n","# Show the best classification model performance\n","best_classification_model = max(classification_accuracies, key=classification_accuracies.get)\n","print(f\"Best Classification Model: {best_classification_model} with accuracy {classification_accuracies[best_classification_model]:.4f}\")\n","\n","# Linear Regression as a regression model (optional for continuous prediction)\n","# Here, we apply Linear Regression if you want to predict a continuous variable, like heart disease progression.\n","linear_regression_model = LinearRegression()  # Initialize Linear Regression model\n","linear_regression_model.fit(X_train_scaled, y_train)  # Train the model on the scaled training data\n","y_pred_linear = linear_regression_model.predict(X_test_scaled)  # Make predictions on the test set\n","\n","# Evaluate Linear Regression results\n","from sklearn.metrics import mean_squared_error, r2_score\n","mse = mean_squared_error(y_test, y_pred_linear)  # Calculate Mean Squared Error (MSE)\n","r2 = r2_score(y_test, y_pred_linear)  # Calculate R-squared score\n","print(f\"\\nLinear Regression Performance:\")\n","print(f\"Mean Squared Error (MSE): {mse:.4f}\")\n","print(f\"R-squared Score: {r2:.4f}\")\n","\n","# Ridge Regression (optional for regularized linear regression)\n","ridge_regression_model = Ridge(alpha=1.0)  # Initialize Ridge Regression model with alpha=1.0 for regularization\n","ridge_regression_model.fit(X_train_scaled, y_train)  # Train Ridge model\n","y_pred_ridge = ridge_regression_model.predict(X_test_scaled)  # Make predictions on the test set\n","\n","# Evaluate Ridge Regression results\n","mse_ridge = mean_squared_error(y_test, y_pred_ridge)  # Calculate Mean Squared Error (MSE)\n","r2_ridge = r2_score(y_test, y_pred_ridge)  # Calculate R-squared score for Ridge\n","print(f\"\\nRidge Regression Performance:\")\n","print(f\"Mean Squared Error (MSE): {mse_ridge:.4f}\")\n","print(f\"R-squared Score: {r2_ridge:.4f}\")\n","\n","# Lasso Regression (optional for L1-regularized regression)\n","lasso_regression_model = Lasso(alpha=0.1)  # Initialize Lasso Regression model with alpha=0.1 for L1 regularization\n","lasso_regression_model.fit(X_train_scaled, y_train)  # Train Lasso model\n","y_pred_lasso = lasso_regression_model.predict(X_test_scaled)  # Make predictions on the test set\n","\n","# Evaluate Lasso Regression results\n","mse_lasso = mean_squared_error(y_test, y_pred_lasso)  # Calculate Mean Squared Error (MSE)\n","r2_lasso = r2_score(y_test, y_pred_lasso)  # Calculate R-squared score for Lasso\n","print(f\"\\nLasso Regression Performance:\")\n","print(f\"Mean Squared Error (MSE): {mse_lasso:.4f}\")\n","print(f\"R-squared Score: {r2_lasso:.4f}\")\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":769},"id":"hSnN-jhDKJos","executionInfo":{"status":"ok","timestamp":1743541368423,"user_tz":-360,"elapsed":1215,"user":{"displayName":"Hasib Al Tahsin","userId":"09702867651229494535"}},"outputId":"2d8ce440-7396-4267-dd00-a07374b252eb"},"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x500 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Best Classification Model: Random Forest with accuracy 0.9708\n","\n","Linear Regression Performance:\n","Mean Squared Error (MSE): 0.3241\n","R-squared Score: 0.7371\n","\n","Ridge Regression Performance:\n","Mean Squared Error (MSE): 0.3748\n","R-squared Score: 0.6960\n","\n","Lasso Regression Performance:\n","Mean Squared Error (MSE): 0.5539\n","R-squared Score: 0.5508\n"]}]},{"cell_type":"markdown","source":["regression analysis"],"metadata":{"id":"6MvqdS2zLYRS"}},{"cell_type":"code","source":["# Import necessary libraries\n","import pandas as pd  # For data manipulation and analysis\n","import numpy as np  # For numerical operations\n","import matplotlib.pyplot as plt  # For plotting graphs and visualizations\n","from sklearn.model_selection import train_test_split  # For splitting the dataset into train and test sets\n","from sklearn.preprocessing import StandardScaler, LabelEncoder  # For scaling features and encoding categorical labels\n","from sklearn.impute import SimpleImputer  # For handling missing values\n","from sklearn.linear_model import LinearRegression, Ridge, Lasso  # For Linear and Regularized Linear regression\n","from sklearn.tree import DecisionTreeRegressor  # For Decision Tree regression model\n","from sklearn.ensemble import RandomForestRegressor  # For Random Forest regression model\n","from sklearn.metrics import mean_squared_error, r2_score  # For evaluating regression performance\n","\n","# Load the dataset\n","file_path = \"ECGCvdata.csv\"  # The path to your CSV dataset (ensure it's correct)\n","df = pd.read_csv(file_path)  # Read the CSV file into a pandas DataFrame\n","\n","# Drop unnecessary columns\n","df.drop(columns=['RECORD'], inplace=True)  # Drop the 'RECORD' column as it's not needed for the regression analysis\n","\n","# Separate features and target variable\n","X = df.drop(columns=['ECG_signal'])  # Feature set: drop the target variable 'ECG_signal' and use the rest as features\n","y = df['ECG_signal']  # Target variable: 'ECG_signal' is the column we want to predict\n","\n","# Check if the target variable contains non-numeric values (important for regression models)\n","print(\"Unique values in ECG_signal:\", y.unique())\n","\n","# If ECG_signal contains categorical labels, encode them as numeric values\n","label_encoder = LabelEncoder()  # Initialize LabelEncoder to convert categorical labels to numeric values\n","y_encoded = label_encoder.fit_transform(y)  # Convert the target variable (ECG_signal) into numeric labels\n","\n","# Handle missing values in the feature set using mean imputation\n","imputer = SimpleImputer(strategy='mean')  # Initialize SimpleImputer to fill missing values with the mean of each feature\n","X_imputed = imputer.fit_transform(X)  # Apply the imputer to the features (X)\n","\n","# Standardize the features: scaling them so they have a mean of 0 and variance of 1\n","scaler = StandardScaler()  # Initialize StandardScaler to standardize features\n","X_scaled = scaler.fit_transform(X_imputed)  # Fit the scaler to the features and transform them\n","\n","# Split the dataset into training and testing sets (80% training, 20% testing)\n","X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_encoded, test_size=0.2, random_state=42)\n","# random_state=42 ensures reproducibility of the split\n","\n","# Define the models for regression analysis\n","regression_models = {\n","    \"Linear Regression\": LinearRegression(),\n","    \"Ridge Regression\": Ridge(alpha=1.0),  # Regularization parameter (alpha) for Ridge Regression\n","    \"Lasso Regression\": Lasso(alpha=0.1),  # Regularization parameter (alpha) for Lasso Regression\n","    \"Decision Tree Regression\": DecisionTreeRegressor(random_state=42),\n","    \"Random Forest Regression\": RandomForestRegressor(n_estimators=100, random_state=42)  # 100 trees for Random Forest\n","}\n","\n","# Dictionary to store results\n","results = {}\n","\n","# Train and evaluate each regression model\n","for name, model in regression_models.items():\n","    # Fit the model to the training data\n","    model.fit(X_train, y_train)\n","\n","    # Make predictions on the test data\n","    y_pred = model.predict(X_test)\n","\n","    # Evaluate the model using Mean Squared Error (MSE) and R-squared\n","    mse = mean_squared_error(y_test, y_pred)  # Calculate the Mean Squared Error\n","    r2 = r2_score(y_test, y_pred)  # Calculate the R-squared value\n","\n","    # Store the evaluation metrics in the results dictionary\n","    results[name] = {\"MSE\": mse, \"R-squared\": r2}\n","\n","    # Print model performance metrics\n","    print(f\"\\n{name} Model Performance:\")\n","    print(f\"Mean Squared Error (MSE): {mse:.4f}\")  # Lower MSE is better\n","    print(f\"R-squared Score: {r2:.4f}\")  # Higher R-squared is better\n","\n","# After the loop, you can perform further analysis like comparing models based on MSE and R-squared:\n","\n","# Extract MSE and R-squared values from the results dictionary\n","mse_values = [metrics[\"MSE\"] for metrics in results.values()]  # MSE values for all models\n","r2_values = [metrics[\"R-squared\"] for metrics in results.values()]  # R-squared values for all models\n","\n","# Plot MSE (lower is better)\n","plt.figure(figsize=(10, 5))\n","plt.bar(results.keys(), mse_values, color='lightblue')\n","plt.ylabel('Mean Squared Error (MSE)')\n","plt.title('MSE Comparison of Regression Models')\n","plt.xticks(rotation=45)  # Rotate x-axis labels for better readability\n","plt.show()  # Show the plot for MSE comparison\n","\n","# Plot R-squared (higher is better)\n","plt.figure(figsize=(10, 5))\n","plt.bar(results.keys(), r2_values, color='lightgreen')\n","plt.ylabel('R-squared Score')\n","plt.title('R-squared Comparison of Regression Models')\n","plt.xticks(rotation=45)  # Rotate x-axis labels for better readability\n","plt.show()  # Show the plot for R-squared comparison\n","\n","# Identify the best models based on performance\n","best_model_mse = min(results, key=lambda x: results[x][\"MSE\"])  # Model with the lowest MSE\n","best_model_r2 = max(results, key=lambda x: results[x][\"R-squared\"])  # Model with the highest R-squared\n","\n","# Print the best models based on MSE and R-squared\n","print(f\"\\nBest Model based on Lowest MSE: {best_model_mse} with MSE: {results[best_model_mse]['MSE']:.4f}\")\n","print(f\"Best Model based on Highest R-squared: {best_model_r2} with R-squared: {results[best_model_r2]['R-squared']:.4f}\")\n","\n","\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"rl7wjhQJMG8h","executionInfo":{"status":"ok","timestamp":1743696810030,"user_tz":-360,"elapsed":3881,"user":{"displayName":"Hasib Al Tahsin","userId":"09702867651229494535"}},"outputId":"5a89d72a-f727-473f-b3dd-b96d1302d70b"},"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["Unique values in ECG_signal: ['ARR' 'AFF' 'CHF' 'NSR']\n","\n","Linear Regression Model Performance:\n","Mean Squared Error (MSE): 0.3241\n","R-squared Score: 0.7371\n","\n","Ridge Regression Model Performance:\n","Mean Squared Error (MSE): 0.3748\n","R-squared Score: 0.6960\n","\n","Lasso Regression Model Performance:\n","Mean Squared Error (MSE): 0.5538\n","R-squared Score: 0.5509\n","\n","Decision Tree Regression Model Performance:\n","Mean Squared Error (MSE): 0.1667\n","R-squared Score: 0.8648\n","\n","Random Forest Regression Model Performance:\n","Mean Squared Error (MSE): 0.0944\n","R-squared Score: 0.9234\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x500 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x500 with 1 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAA04AAAJBCAYAAABxgeXgAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnXlJREFUeJzs3Xd0FNX/xvEnPSSQUEPvKEWQKE1pIkQQFESkdxSQpkgHBULvIt0AgtJ7U0qoAlIFgnzp0nsnECAh9f7+4GR/WRJcooEN8H6dw9HMzsx+dnMzM8/MnTsOxhgjAAAAAMATOdq7AAAAAABI7ghOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgDwDDk4OKhfv372LuOFUKFCBVWoUMHeZfxne/bsUenSpeXp6SkHBwf99ddf9i4pWfvll1/k4OCgs2fP2ruU56Zfv35ycHD4V8s2b95cuXLlStqCADwVghOAfxR7UBP7z9nZWVmzZlXz5s116dIle5f3UgkJCVH//v1VtGhRpUyZUilSpFDhwoXVo0cPXb582d7l4SlERkaqTp06un37tn744QfNmjVLOXPmTHDezZs3W/1tOTk5ycfHR7Vr19bRo0efc+Wvply5csnBwUF+fn4Jvj516lTL72fv3r3PuToAyY2zvQsA8GIYMGCAcufOrYcPH2rXrl365ZdftG3bNh06dEju7u72Lu+Fd/r0afn5+en8+fOqU6eOWrduLVdXV/3vf//TtGnTtGzZMv3999/2LvOZWrdunb1L+M9OnTqlc+fOaerUqWrZsuVTLfP111+rRIkSioyM1P/+9z8FBARo8+bNOnTokDJlyvSMK7a/Jk2aqH79+nJzc7PL+7u7u+v333/X1atX433fc+bMkbu7ux4+fGiX2gAkLwQnAE+latWqKl68uCSpZcuWSp8+vYYPH65ff/1VdevWtXN1SS80NFQeHh7P5b2ioqJUq1YtXbt2TZs3b1bZsmWtXh88eLCGDx/+XGqxh9jv2tXV1d6l/GfXr1+XJKVOnfqplylXrpxq165t+Tl//vxq27atZs6cqe7duyd1if/oebb7WE5OTnJycnqu7xlXmTJltGfPHi1YsEAdO3a0TL948aL++OMPffrpp1qyZInd6gOQfNBVD8C/Uq5cOUmPzrDbcvXqVbVo0ULZsmWTm5ubMmfOrE8++cTqngZjjAYNGqRs2bLJw8ND77//vg4fPqxcuXKpefPmlvmedG9AQvdJrFixQh999JGyZMkiNzc35c2bVwMHDlR0dLTVshUqVFDhwoW1b98+lS9fXh4eHvr2228lSeHh4fL391e+fPnk5uam7Nmzq3v37goPD7daR3h4uDp16qQMGTIoVapUqlGjhi5evGjzu5GkJUuW6MCBA/ruu+/ihSZJ8vLy0uDBg62mLVq0SMWKFVOKFCmUPn16NW7cOF7XyebNmytlypQ6f/68Pv74Y6VMmVJZs2bVxIkTJUkHDx5UxYoV5enpqZw5c2ru3LkJfqdbt27Vl19+qXTp0snLy0tNmzZVcHCw1bxJ8V0ndI/T+PHj9cYbb8jDw0Np0qRR8eLF49W5f/9+Va1aVV5eXkqZMqUqVaqkXbt2JfhZtm/frs6dOytDhgzy9PTUp59+qhs3biT0a4ln06ZNKleunDw9PZU6dWp98sknVl3qmjdvrvfee0+SVKdOHTk4OPyre7ae9Ld16dIlff7558qYMaPc3Nz0xhtvaPr06fGWP3funGrUqCFPT0/5+PioU6dOWrt2rRwcHLR582bLfEnR7tevX6+yZcsqderUSpkypfLnz29ZRyxbv8Mn3eM0adIkvfHGG3Jzc1OWLFnUvn173blzx2qe2M9w5MgRvf/++/Lw8FDWrFk1YsSIp/qupUdXnGrVqhWvXc2bN09p0qRRlSpVElzOVnuItW3bNpUoUULu7u7KmzevJk+e/MRaZs+ebfm7Tps2rerXr68LFy7Y/Azz589XsWLFlCpVKnl5ealIkSIaO3aszeUAJA5XnAD8K7EHOWnSpLE572effabDhw/rq6++Uq5cuXT9+nWtX79e58+ft9zk3LdvXw0aNEjVqlVTtWrVFBQUpMqVKysiIuJf1/jLL78oZcqU6ty5s1KmTKlNmzapb9++CgkJ0ciRI63mvXXrlqpWrar69eurcePGypgxo2JiYlSjRg1t27ZNrVu3VsGCBXXw4EH98MMP+vvvv7V8+XLL8i1bttTs2bPVsGFDlS5dWps2bdJHH330VHX++uuvkh51WXraz9WiRQuVKFFCQ4cO1bVr1zR27Fht375d+/fvt7raER0drapVq6p8+fIaMWKE5syZow4dOsjT01PfffedGjVqpFq1aikgIEBNmzbVu+++q9y5c1u9X4cOHZQ6dWr169dPx48f148//qhz585Z7tFJiu86IVOnTtXXX3+t2rVrq2PHjnr48KH+97//affu3WrYsKEk6fDhwypXrpy8vLzUvXt3ubi4aPLkyapQoYK2bNmiUqVKWa3zq6++Upo0aeTv76+zZ89qzJgx6tChgxYsWPCP3/mGDRtUtWpV5cmTR/369VNYWJjGjx+vMmXKKCgoSLly5dKXX36prFmzasiQIZbud0/6bP8kob+ta9eu6Z133pGDg4M6dOigDBkyaM2aNfriiy8UEhKib775RpL04MEDVaxYUVeuXFHHjh2VKVMmzZ07V7///nuC7/Vf2v3hw4f18ccf680339SAAQPk5uamkydPavv27Zb1P83vMCH9+vVT//795efnp7Zt21ra3Z49e7R9+3a5uLhY5g0ODtaHH36oWrVqqW7dulq8eLF69OihIkWKqGrVqk/1nTds2FCVK1fWqVOnlDdvXknS3LlzVbt2bav3ivU07UF6dHKicuXKypAhg/r166eoqCj5+/sn2C4GDx6sPn36qG7dumrZsqVu3Lih8ePHq3z58vH+ruNav369GjRooEqVKlmuTB89elTbt2+3uoIGIAkYAPgHP//8s5FkNmzYYG7cuGEuXLhgFi9ebDJkyGDc3NzMhQsX/nH54OBgI8mMHDnyifNcv37duLq6mo8++sjExMRYpn/77bdGkmnWrJllmr+/v0lo0xVb55kzZyzTQkND48335ZdfGg8PD/Pw4UPLtPfee89IMgEBAVbzzpo1yzg6Opo//vjDanpAQICRZLZv326MMeavv/4ykky7du2s5mvYsKGRZPz9/Z/42Y0x5q233jLe3t7/OE+siIgI4+PjYwoXLmzCwsIs01euXGkkmb59+1qmNWvWzEgyQ4YMsUwLDg42KVKkMA4ODmb+/PmW6ceOHYtXa+x3WqxYMRMREWGZPmLECCPJrFixwjLtv37Xsa+99957lp8/+eQT88Ybb/zj91GzZk3j6upqTp06ZZl2+fJlkypVKlO+fPl4n8XPz8+qjXXq1Mk4OTmZO3fu/OP7+Pr6Gh8fH3Pr1i3LtAMHDhhHR0fTtGlTy7Tff//dSDKLFi36x/XFnXf69Onmxo0b5vLlyyYwMNDky5fPODg4mD///NMy7xdffGEyZ85sbt68abWO+vXrG29vb8v3//333xtJZvny5ZZ5wsLCTIECBYwk8/vvv1um/9d2/8MPPxhJ5saNG0/8jE/zO3z8bzd2e1C5cmUTHR1tmW/ChAmW7+vxzzBz5kzLtPDwcJMpUybz2Wef/eP7GmNMzpw5zUcffWSioqJMpkyZzMCBA40xxhw5csRIMlu2bLHUt2fPHstyT9seatasadzd3c25c+cs044cOWKcnJystmNnz541Tk5OZvDgwVb1HTx40Dg7O1tNb9asmcmZM6fl544dOxovLy8TFRVl8/MC+G/oqgfgqfj5+SlDhgzKnj27ateuLU9PT/3666/Kli3bPy6XIkUKubq6avPmzfG6d8XasGGDIiIi9NVXX1l1w4s9i/5vpUiRwvL/9+7d082bN1WuXDmFhobq2LFjVvO6ubmpRYsWVtMWLVqkggULqkCBArp586blX8WKFSXJchZ/9erVkh7d5B/X09YfEhKiVKlSPdW8e/fu1fXr19WuXTurQTk++ugjFShQQKtWrYq3TNxBClKnTq38+fPL09PT6t60/PnzK3Xq1Dp9+nS85Vu3bm111r1t27Zydna2fG7pv3/XCUmdOrUuXryoPXv2JPh6dHS01q1bp5o1aypPnjyW6ZkzZ1bDhg21bds2hYSExPsscdtYuXLlFB0drXPnzj2xjitXruivv/5S8+bNlTZtWsv0N998Ux988IHV9/BvfP7558qQIYOyZMmiDz/8UHfv3tWsWbNUokQJSY+6sS5ZskTVq1eXMcaqLVapUkV3795VUFCQJCkwMFBZs2ZVjRo1LOt3d3dXq1atEnzv/9LuY6+ArFixQjExMQmu39bvMCGx24NvvvlGjo7/f5jSqlUreXl5xWvjKVOmVOPGjS0/u7q6qmTJkgm25SdxcnJS3bp1NW/ePEmPBoXInj27pdtkXE/bHqKjo7V27VrVrFlTOXLksMxXsGDBeN3/li5dqpiYGNWtW9fqO8+UKZNee+21J14xlB59xw8ePND69euf+vMC+HcITgCeysSJE7V+/XotXrxY1apV082bN61GwYqIiNDVq1et/kVHR8vNzU3Dhw/XmjVrlDFjRkuXsatXr1qWjT1ofe2116zeM0OGDE/VFfBJDh8+rE8//VTe3t7y8vJShgwZLAdYd+/etZo3a9as8QYnOHHihA4fPqwMGTJY/Xv99dcl/f9AAOfOnZOjo6Oli0+s/PnzP1WdXl5eunfv3lPNG/tdJbTuAgUKxAsA7u7uypAhg9U0b29vZcuWLd69Yt7e3gmG28d/LylTplTmzJmt7kn5r991Qnr06KGUKVOqZMmSeu2119S+fXurbmA3btxQaGhogt9FwYIFFRMTE+/+kLgHsNL/d4d7UqiX/vk7L1iwoG7evKkHDx7Y/DxP0rdvX61fv17Lli1T06ZNdffuXavAcOPGDd25c0dTpkyJ1xZjQ0/ctpg3b954v9t8+fIl+N7/pd3Xq1dPZcqUUcuWLZUxY0bVr19fCxcutApRtn6HCXnS9+3q6qo8efLEa+MJteU0adL84+80IQ0bNtSRI0d04MABzZ07V/Xr10/wfsqnbQ83btxQWFhYvL+fhJY9ceKEjDF67bXX4n3vR48etXznCWnXrp1ef/11Va1aVdmyZdPnn3+uwMDARH12AE+He5wAPJWSJUtaRtWrWbOmypYtq4YNG+r48eNKmTKlduzYoffff99qmTNnzihXrlz65ptvVL16dS1fvlxr165Vnz59NHToUG3atElvvfVWoup40kMjHx+E4M6dO3rvvffk5eWlAQMGKG/evHJ3d1dQUJB69OgR7wx53CsmsWJiYlSkSBGNHj06wffMnj17omp/kgIFCmj//v26cOFCkq0z1pNGK3vSdGNMot8jKb7rhBQsWFDHjx/XypUrFRgYqCVLlmjSpEnq27ev+vfvn+g6paT93EmlSJEilucI1axZU6GhoWrVqpXKli2r7NmzW76/xo0bq1mzZgmu48033/xX7/1f2n2KFCm0detW/f7771q1apUCAwO1YMECVaxYUevWrZOTk9Mz+R0+Lql+p6VKlVLevHn1zTff6MyZM/94D1ZSi4mJkYODg9asWZPg50mZMuUTl/Xx8dFff/2ltWvXas2aNVqzZo1+/vlnNW3aVDNmzHiWZQOvHIITgERzcnLS0KFD9f7772vChAnq2bOnihYtGq+rSNxnouTNm1ddunRRly5ddOLECfn6+ur777/X7NmzLQ8IPXHihFWXqxs3bsQ7axx7heDOnTtWN0s/fhZ68+bNunXrlpYuXary5ctbpp85c+apP2fevHl14MABVapU6YmBTZJy5sypmJgYnTp1yupM8vHjx5/qfapXr6558+Zp9uzZ6tWr1z/OG/tdHT9+3NJ1Ku77Pelhq//FiRMnrELx/fv3deXKFVWrVk1S0nzXT+Lp6al69eqpXr16ioiIUK1atTR48GD16tVLGTJkkIeHR4Lf87Fjx+To6JgkQTTud57Q+6RPn16enp7/+X1iDRs2TMuWLdPgwYMVEBBgGakxOjr6iQ9qjVvrkSNHZIyxarMnT5586vd/2nYvSY6OjqpUqZIqVaqk0aNHa8iQIfruu+/0+++/W2r9p99hQs+Ai/t9x90eRERE6MyZMza/g/+iQYMGGjRokAoWLChfX98E53na9uDu7q4UKVLoxIkT8eZ7fNm8efPKGKPcuXNbruwlhqurq6pXr67q1asrJiZG7dq10+TJk9WnT58nXm0EkHh01QPwr1SoUEElS5bUmDFj9PDhQ6VJk0Z+fn5W/9zd3RUaGhrv4ZF58+ZVqlSpLEMb+/n5ycXFRePHj7c6SzxmzJh47xvbHW7r1q2WaQ8ePIh3ZjX2rG3c9UVERGjSpElP/Rnr1q2rS5cuaerUqfFeCwsLs3TPih25a9y4cVbzJFR/QmrXrq0iRYpo8ODB2rlzZ7zX7927p++++06SVLx4cfn4+CggIMBqaOg1a9bo6NGjTz2SX2JMmTJFkZGRlp9//PFHRUVFWT53UnzXCbl165bVz66uripUqJCMMYqMjJSTk5MqV66sFStWWHUbvHbtmubOnauyZcvKy8vrP9UgPbpnytfXVzNmzLAaDvvQoUNat26dJUAmlbx58+qzzz7TL7/8oqtXr8rJyUmfffaZlixZokOHDsWbP+5w6lWqVNGlS5csIzVK0sOHDxNsw0/ytO3+9u3b8V6PDRuxbdPW7zAhfn5+cnV11bhx46za1LRp03T37t1n0sZjtWzZUv7+/vr++++fOM/TtgcnJydVqVJFy5cv1/nz5y3zHT16VGvXrrVaZ61ateTk5KT+/fvHu1JmjIn3Pcb1+GuOjo6WK5CPDx8P4L/hihOAf61bt26qU6eOfvnlF7Vp0ybBef7++29VqlRJdevWVaFCheTs7Kxly5bp2rVrql+/vqRH9zJ17dpVQ4cO1ccff6xq1app//79WrNmjdKnT2+1vsqVKytHjhz64osv1K1bNzk5OWn69OnKkCGD1cFJ6dKllSZNGjVr1kxff/21HBwcNGvWrER132nSpIkWLlyoNm3a6Pfff1eZMmUUHR2tY8eOaeHChVq7dq2KFy8uX19fNWjQQJMmTdLdu3dVunRpbdy48anP8ru4uGjp0qXy8/NT+fLlVbduXZUpU0YuLi46fPiw5s6dqzRp0mjw4MFycXHR8OHD1aJFC7333ntq0KCBZTjyXLlyqVOnTk/9+Z5WRESE5Xd4/PhxTZo0SWXLlrUMQJAU33VCKleurEyZMqlMmTLKmDGjjh49qgkTJuijjz6yDKYxaNAgy7OE2rVrJ2dnZ02ePFnh4eGJepaPLSNHjlTVqlX17rvv6osvvrAMP+3t7a1+/fol2fvE6tatmxYuXKgxY8Zo2LBhGjZsmH7//XeVKlVKrVq1UqFChXT79m0FBQVpw4YNlhDz5ZdfasKECWrQoIE6duyozJkza86cOZYrO7auIElP3+4HDBigrVu36qOPPlLOnDl1/fp1TZo0SdmyZbM8j+xpfoePy5Ahg3r16qX+/fvrww8/VI0aNSztrkSJElYDQSS1nDlzPtXv82nbQ//+/RUYGKhy5cqpXbt2ioqKsjzX6n//+59lvrx582rQoEHq1auXzp49q5o1aypVqlQ6c+aMli1bptatW6tr164J1tKyZUvdvn1bFStWVLZs2XTu3DmNHz9evr6+Kliw4H/9SgDE9byH8QPwYkloKN5Y0dHRJm/evCZv3rxPHAr35s2bpn379qZAgQLG09PTeHt7m1KlSpmFCxfGW1f//v1N5syZTYoUKUyFChXMoUOHTM6cOa2GIzfGmH379plSpUoZV1dXkyNHDjN69OgEhyPfvn27eeedd0yKFClMlixZTPfu3c3atWsTHJb5SUMmR0REmOHDh5s33njDuLm5mTRp0phixYqZ/v37m7t371rmCwsLM19//bVJly6d8fT0NNWrVzcXLlx4quHIYwUHB5u+ffuaIkWKGA8PD+Pu7m4KFy5sevXqZa5cuWI174IFC8xbb71l3NzcTNq0aU2jRo3MxYsXreZp1qyZ8fT0jPc+T/q8sUMzx4r9Trds2WJat25t0qRJY1KmTGkaNWpkNQyzMUnzXT8+HPnkyZNN+fLlTbp06Yybm5vJmzev6datm9X3bowxQUFBpkqVKiZlypTGw8PDvP/++2bHjh1W8zypHccOCR63xifZsGGDKVOmjEmRIoXx8vIy1atXN0eOHElwfYkZjvxJ81aoUMF4eXlZhkq/du2aad++vcmePbtxcXExmTJlMpUqVTJTpkyxWu706dPmo48+MilSpDAZMmQwXbp0MUuWLDGSzK5duyzz/dd2v3HjRvPJJ5+YLFmyGFdXV5MlSxbToEED8/fff1vW8zS/w4T+do15NPx4gQIFjIuLi8mYMaNp27atCQ4OtprnSZ/h8SG7n+TxNp+QJ7Wdp2kPxhizZcsWU6xYMePq6mry5MljAgICnvhYhSVLlpiyZcsaT09P4+npaQoUKGDat29vjh8//sTPtnjxYlO5cmXj4+Nj2SZ++eWX8bYZAP47B2PseEcsANiQK1cuVahQQb/88ou9S3nlxD5od8+ePZaBQfBiGjNmjDp16qSLFy8qa9as9i4HAF5I3OMEAMBLJCwszOrnhw8favLkyXrttdcITQDwH3CPEwAAL5FatWopR44c8vX11d27dzV79mwdO3ZMc+bMsXdpAPBCIzgBAPASqVKlin766SfNmTNH0dHRKlSokObPn6969erZuzQAeKFxjxMAAAAA2MA9TgAAAABgA8EJAAAAAGx45e5xiomJ0eXLl5UqVaqnehAgAAAAgJeTMUb37t1TlixZ5Oj4z9eUXrngdPnyZWXPnt3eZQAAAABIJi5cuKBs2bL94zyvXHBKlSqVpEdfjpeXl52rAQAAAGAvISEhyp49uyUj/JNXLjjFds/z8vIiOAEAAAB4qlt4GBwCAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAG5ztXQAAAADwT8YGj7V3CUhiHdN0tHcJicYVJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYIOzvQsAAAAvp7HBY+1dApJYxzQd7V0CYDdccQIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwwe7BaeLEicqVK5fc3d1VqlQp/fnnn/84/5gxY5Q/f36lSJFC2bNnV6dOnfTw4cPnVC0AAACAV5Fdg9OCBQvUuXNn+fv7KygoSEWLFlWVKlV0/fr1BOefO3euevbsKX9/fx09elTTpk3TggUL9O233z7nygEAAAC8SuwanEaPHq1WrVqpRYsWKlSokAICAuTh4aHp06cnOP+OHTtUpkwZNWzYULly5VLlypXVoEEDm1epAAAAAOC/sFtwioiI0L59++Tn5/f/xTg6ys/PTzt37kxwmdKlS2vfvn2WoHT69GmtXr1a1apVe+L7hIeHKyQkxOofAAAAACSGs73e+ObNm4qOjlbGjBmtpmfMmFHHjh1LcJmGDRvq5s2bKlu2rIwxioqKUps2bf6xq97QoUPVv3//JK0dAAAAwKvF7oNDJMbmzZs1ZMgQTZo0SUFBQVq6dKlWrVqlgQMHPnGZXr166e7du5Z/Fy5ceI4VAwAAAHgZ2O2KU/r06eXk5KRr165ZTb927ZoyZcqU4DJ9+vRRkyZN1LJlS0lSkSJF9ODBA7Vu3VrfffedHB3j50A3Nze5ubkl/QcAAAAA8Mqw2xUnV1dXFStWTBs3brRMi4mJ0caNG/Xuu+8muExoaGi8cOTk5CRJMsY8u2IBAAAAvNLsdsVJkjp37qxmzZqpePHiKlmypMaMGaMHDx6oRYsWkqSmTZsqa9asGjp0qCSpevXqGj16tN566y2VKlVKJ0+eVJ8+fVS9enVLgAIAAACApGbX4FSvXj3duHFDffv21dWrV+Xr66vAwEDLgBHnz5+3usLUu3dvOTg4qHfv3rp06ZIyZMig6tWra/Dgwfb6CAAAAABeAQ7mFevjFhISIm9vb929e1deXl72LgcAgJfW2OCx9i4BSaxjmo52eV/a0svHXm3pcYnJBi/UqHoAAAAAYA8EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALDB2d4FQBobPNbeJSCJdUzT0d4lAAAAIAlxxQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbnO1dAICkMTZ4rL1LwDPQMU1He5cAAADEFScAAAAAsIngBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABv+VXD6448/1LhxY7377ru6dOmSJGnWrFnatm1bkhYHAAAAAMlBooPTkiVLVKVKFaVIkUL79+9XeHi4JOnu3bsaMmRIkhcIAAAAAPaW6OA0aNAgBQQEaOrUqXJxcbFML1OmjIKCgpK0OAAAAABIDhIdnI4fP67y5cvHm+7t7a07d+4kRU0AAAAAkKwkOjhlypRJJ0+ejDd927ZtypMnT5IUBQAAAADJSaKDU6tWrdSxY0ft3r1bDg4Ounz5subMmaOuXbuqbdu2iS5g4sSJypUrl9zd3VWqVCn9+eef/zj/nTt31L59e2XOnFlubm56/fXXtXr16kS/LwAAAAA8LefELtCzZ0/FxMSoUqVKCg0NVfny5eXm5qauXbvqq6++StS6FixYoM6dOysgIEClSpXSmDFjVKVKFR0/flw+Pj7x5o+IiNAHH3wgHx8fLV68WFmzZtW5c+eUOnXqxH4MAAAAAHhqiQpO0dHR2r59u9q3b69u3brp5MmTun//vgoVKqSUKVMm+s1Hjx6tVq1aqUWLFpKkgIAArVq1StOnT1fPnj3jzT99+nTdvn1bO3bssAxMkStXrn98j/DwcMvIf5IUEhKS6DoBAAAAvNoS1VXPyclJlStXVnBwsFxdXVWoUCGVLFnyX4WmiIgI7du3T35+fv9fjKOj/Pz8tHPnzgSX+fXXX/Xuu++qffv2ypgxowoXLqwhQ4YoOjr6ie8zdOhQeXt7W/5lz5490bUCAAAAeLUl+h6nwoUL6/Tp0//5jW/evKno6GhlzJjRanrGjBl19erVBJc5ffq0Fi9erOjoaK1evVp9+vTR999/r0GDBj3xfXr16qW7d+9a/l24cOE/1w4AAADg1ZLoe5wGDRqkrl27auDAgSpWrJg8PT2tXvfy8kqy4h4XExMjHx8fTZkyRU5OTipWrJguXbqkkSNHyt/fP8Fl3Nzc5Obm9sxqAgAAAPDyS3RwqlatmiSpRo0acnBwsEw3xsjBweEfu83FlT59ejk5OenatWtW069du6ZMmTIluEzmzJnl4uIiJycny7SCBQvq6tWrioiIkKura2I/DgAAAADYlOjg9PvvvyfJG7u6uqpYsWLauHGjatasKenRFaWNGzeqQ4cOCS5TpkwZzZ07VzExMXJ0fNTL8O+//1bmzJkJTQAAAACemUQHp/feey/J3rxz585q1qyZihcvrpIlS2rMmDF68OCBZZS9pk2bKmvWrBo6dKgkqW3btpowYYI6duyor776SidOnNCQIUP09ddfJ1lNAAAAAPC4RAcn6dFDaKdNm6ajR49Kkt544w19/vnn8vb2TtR66tWrpxs3bqhv3766evWqfH19FRgYaBkw4vz585YrS5KUPXt2rV27Vp06ddKbb76prFmzqmPHjurRo8e/+RgAAAAA8FQSHZz27t2rKlWqKEWKFCpZsqSkR89jGjx4sNatW6e33347Uevr0KHDE7vmbd68Od60d999V7t27Ups2QAAAADwryU6OHXq1Ek1atTQ1KlT5ez8aPGoqCi1bNlS33zzjbZu3ZrkRQIAAACAPf2rK05xQ5MkOTs7q3v37ipevHiSFgcAAAAAyUGiH4Dr5eWl8+fPx5t+4cIFpUqVKkmKAgAAAIDkJNHBqV69evriiy+0YMECXbhwQRcuXND8+fPVsmVLNWjQ4FnUCAAAAAB2leiueqNGjZKDg4OaNm2qqKgoSZKLi4vatm2rYcOGJXmBAAAAAGBviQ5Orq6uGjt2rIYOHapTp05JkvLmzSsPD48kLw4AAAAAkoNEB6e7d+8qOjpaadOmVZEiRSzTb9++LWdnZ3l5eSVpgQAAAABgb4m+x6l+/fqaP39+vOkLFy5U/fr1k6QoAAAAAEhOEh2cdu/erffffz/e9AoVKmj37t1JUhQAAAAAJCeJDk7h4eGWQSHiioyMVFhYWJIUBQAAAADJSaKDU8mSJTVlypR40wMCAlSsWLEkKQoAAAAAkpNEDw4xaNAg+fn56cCBA6pUqZIkaePGjdqzZ4/WrVuX5AUCAAAAgL0lOjiVKVNGO3fu1MiRI7Vw4UKlSJFCb775pqZNm6bXXnvtWdQIAHiOxgaPtXcJSGId03S0dwkA8MJLdHCSJF9fX82ZMyepawEAAACAZOmpg1NUVJSio6Pl5uZmmXbt2jUFBATowYMHqlGjhsqWLftMigQAAAAAe3rq4NSqVSu5urpq8uTJkqR79+6pRIkSevjwoTJnzqwffvhBK1asULVq1Z5ZsQAAAABgD089qt727dv12WefWX6eOXOmoqOjdeLECR04cECdO3fWyJEjn0mRAAAAAGBPTx2cLl26ZDX4w8aNG/XZZ5/J29tbktSsWTMdPnw46SsEAAAAADt76uDk7u5u9YDbXbt2qVSpUlav379/P2mrAwAAAIBk4KmDk6+vr2bNmiVJ+uOPP3Tt2jVVrFjR8vqpU6eUJUuWpK8QAAAAAOzsqQeH6Nu3r6pWraqFCxfqypUrat68uTJnzmx5fdmyZSpTpswzKRIAAAAA7Ompg9N7772nffv2ad26dcqUKZPq1Klj9bqvr69KliyZ5AUCAAAAgL0l6gG4BQsWVMGCBRN8rXXr1klSEAAAAAAkN099jxMAAAAAvKoITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALDhqUbVS5MmjRwcHJ5qhbdv3/5PBQEAAABAcvNUwWnMmDGW/79165YGDRqkKlWq6N1335Uk7dy5U2vXrlWfPn2eSZEAAAAAYE9PFZyaNWtm+f/PPvtMAwYMUIcOHSzTvv76a02YMEEbNmxQp06dkr5KAAAAALCjRN/jtHbtWn344Yfxpn/44YfasGFDkhQFAAAAAMlJooNTunTptGLFinjTV6xYoXTp0iVJUQAAAACQnDxVV724+vfvr5YtW2rz5s0qVaqUJGn37t0KDAzU1KlTk7xAAAAAALC3RAen5s2bq2DBgho3bpyWLl0qSSpYsKC2bdtmCVIAAAAA8DJJdHCSpFKlSmnOnDlJXQsAAAAAJEv/6gG4p06dUu/evdWwYUNdv35dkrRmzRodPnw4SYsDAAAAgOQg0cFpy5YtKlKkiHbv3q0lS5bo/v37kqQDBw7I398/yQsEAAAAAHtLdHDq2bOnBg0apPXr18vV1dUyvWLFitq1a1eSFgcAAAAAyUGig9PBgwf16aefxpvu4+OjmzdvJklRAAAAAJCcJDo4pU6dWleuXIk3ff/+/cqaNWuSFAUAAAAAyUmig1P9+vXVo0cPXb16VQ4ODoqJidH27dvVtWtXNW3a9FnUCAAAAAB2lejgNGTIEBUoUEDZs2fX/fv3VahQIZUvX16lS5dW7969n0WNAAAAAGBXiXqOkzFGV69e1bhx49S3b18dPHhQ9+/f11tvvaXXXnvtWdUIAAAAAHaV6OCUL18+HT58WK+99pqyZ8/+rOoCAAAAgGQjUV31HB0d9dprr+nWrVvPqh4AAAAASHYSfY/TsGHD1K1bNx06dOhZ1AMAAAAAyU6iuupJUtOmTRUaGqqiRYvK1dVVKVKksHr99u3bSVYcAAAAACQHiQ5OY8aMeQZlAAAAAEDylejg1KxZs2dRBwAAAAAkW4kOTnE9fPhQERERVtO8vLz+U0EAAAAAkNwkenCIBw8eqEOHDvLx8ZGnp6fSpElj9Q8AAAAAXjaJDk7du3fXpk2b9OOPP8rNzU0//fST+vfvryxZsmjmzJnPokYAAAAAsKtEd9X77bffNHPmTFWoUEEtWrRQuXLllC9fPuXMmVNz5sxRo0aNnkWdAAAAAGA3ib7idPv2beXJk0fSo/uZYocfL1u2rLZu3Zq01QEAAABAMpDo4JQnTx6dOXNGklSgQAEtXLhQ0qMrUalTp07S4gAAAAAgOUh0cGrRooUOHDggSerZs6cmTpwod3d3derUSd26dUvyAgEAAADA3hJ9j1OnTp0s/+/n56djx45p3759ypcvn958880kLQ4AAAAAkoP/9BwnScqZM6dy5syZFLUAAAAAQLKU6OA0YMCAf3y9b9++/7oYAAAAAEiOEh2cli1bZvVzZGSkzpw5I2dnZ+XNm5fgBAAAAOClk+jgtH///njTQkJC1Lx5c3366adJUhQAAAAAJCeJHlUvIV5eXurfv7/69OmTFKsDAAAAgGQlSYKTJN29e1d3795NqtUBAAAAQLKR6K5648aNs/rZGKMrV65o1qxZqlq1apIVBgAAAADJRaKD0w8//GD1s6OjozJkyKBmzZqpV69eSVYYAAAAACQXiQ5OZ86ceRZ1AAAAAECylWT3OAEAAADAyyrRV5w+/fRTOTg4PNW8S5cufar5Jk6cqJEjR+rq1asqWrSoxo8fr5IlS9pcbv78+WrQoIE++eQTLV++/KneCwAAAAASK9FXnLy9vbVx40bt3bvXMm3fvn3atGmTvLy85O3tbfn3NBYsWKDOnTvL399fQUFBKlq0qKpUqaLr16//43Jnz55V165dVa5cucR+BAAAAABIlERfccqYMaPq1q2rgIAAOTk5SZKio6PVrl07eXl5aeTIkYla3+jRo9WqVSu1aNFCkhQQEKBVq1Zp+vTp6tmzZ4LLREdHq1GjRurfv7/++OMP3blzJ7EfAwAAAACeWqKvOE2fPl1du3a1hCZJcnJyUufOnTV9+vRErSsiIkL79u2Tn5/f/xfk6Cg/Pz/t3LnzicsNGDBAPj4++uKLL2y+R3h4uEJCQqz+AQAAAEBiJDo4RUVF6dixY/GmHzt2TDExMYla182bNxUdHa2MGTNaTc+YMaOuXr2a4DLbtm3TtGnTNHXq1Kd6j6FDh1p1H8yePXuiagQAAACARHfVa9Gihb744gudOnXKMoDD7t27NWzYMEt3u2fl3r17atKkiaZOnar06dM/1TK9evVS586dLT+HhIQQngAAAAAkSqKD06hRo5QpUyZ9//33unLliiQpc+bM6tatm7p06ZKodaVPn15OTk66du2a1fRr164pU6ZM8eY/deqUzp49q+rVq1umxV7lcnZ21vHjx5U3b16rZdzc3OTm5paougAAAAAgrkQHJ0dHR3Xv3l3du3e33C/k5eX1r97c1dVVxYoV08aNG1WzZk1Jj4LQxo0b1aFDh3jzFyhQQAcPHrSa1rt3b927d09jx47lShIAAACAZyLRwSksLEzGGHl4eMjLy0vnzp3T9OnTVahQIVWuXDnRBXTu3FnNmjVT8eLFVbJkSY0ZM0YPHjywdPtr2rSpsmbNqqFDh8rd3V2FCxe2Wj516tSSFG86AAAAACSVRAenTz75RLVq1VKbNm10584dlSxZUq6urrp586ZGjx6ttm3bJmp99erV040bN9S3b19dvXpVvr6+CgwMtAwYcf78eTk6JnoMCwAAAABIMokOTkFBQfrhhx8kSYsXL1amTJm0f/9+LVmyRH379k10cJKkDh06JNg1T5I2b978j8v+8ssviX4/AAAAAEiMRF/KCQ0NVapUqSRJ69atU61ateTo6Kh33nlH586dS/ICAQAAAMDeEh2c8uXLp+XLl+vChQtau3at5b6m69ev/+tBIgAAAAAgOUt0cOrbt6+6du2qXLlyqWTJknr33XclPbr69NZbbyV5gQAAAABgb4m+x6l27doqW7asrly5oqJFi1qmV6pUSZ9++mmSFgcAAAAAycG/Gq4uU6ZMeuutt7RgwQI9ePBAklSyZEkVKFAgSYsDAAAAgOTgP43z/eWXX+ratWtJVQsAAAAAJEv/KTgZY5KqDgAAAABItniyLAAAAADY8J+C05o1a5Q1a1bLz2FhYf+5IAAAAABIbv5TcCpbtqzc3NwUHh6u77//Xrlz506qugAAAAAg2Xjq4BQeHq5evXqpePHiKl26tJYvXy5J+vnnn5U7d26NGTNGnTp1elZ1AgAAAIDdPPVznPr27avJkyfLz89PO3bsUJ06ddSiRQvt2rVLo0ePVp06deTk5PQsawUAAAAAu3jq4LRo0SLNnDlTNWrU0KFDh/Tmm28qKipKBw4ckIODw7OsEQAAAADs6qm76l28eFHFihWTJBUuXFhubm7q1KkToQkAAADAS++pg1N0dLRcXV0tPzs7OytlypTPpCgAAAAASE6euqueMUbNmzeXm5ubJOnhw4dq06aNPD09reZbunRp0lYIAAAAAHb21MGpWbNmVj83btw4yYsBAAAAgOToqYPTzz///CzrAAAAAIBk6z89ABcAAAAAXgUEJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwIVkEp4kTJypXrlxyd3dXqVKl9Oeffz5x3qlTp6pcuXJKkyaN0qRJIz8/v3+cHwAAAAD+K7sHpwULFqhz587y9/dXUFCQihYtqipVquj69esJzr9582Y1aNBAv//+u3bu3Kns2bOrcuXKunTp0nOuHAAAAMCrwu7BafTo0WrVqpVatGihQoUKKSAgQB4eHpo+fXqC88+ZM0ft2rWTr6+vChQooJ9++kkxMTHauHHjc64cAAAAwKvCrsEpIiJC+/btk5+fn2Wao6Oj/Pz8tHPnzqdaR2hoqCIjI5U2bdoEXw8PD1dISIjVPwAAAABIDLsGp5s3byo6OloZM2a0mp4xY0ZdvXr1qdbRo0cPZcmSxSp8xTV06FB5e3tb/mXPnv0/1w0AAADg1WL3rnr/xbBhwzR//nwtW7ZM7u7uCc7Tq1cv3b171/LvwoULz7lKAAAAAC86Z3u+efr06eXk5KRr165ZTb927ZoyZcr0j8uOGjVKw4YN04YNG/Tmm28+cT43Nze5ubklSb0AAAAAXk12veLk6uqqYsWKWQ3sEDvQw7vvvvvE5UaMGKGBAwcqMDBQxYsXfx6lAgAAAHiF2fWKkyR17txZzZo1U/HixVWyZEmNGTNGDx48UIsWLSRJTZs2VdasWTV06FBJ0vDhw9W3b1/NnTtXuXLlstwLlTJlSqVMmdJunwMAAADAy8vuwalevXq6ceOG+vbtq6tXr8rX11eBgYGWASPOnz8vR8f/vzD2448/KiIiQrVr17Zaj7+/v/r16/c8SwcAAADwirB7cJKkDh06qEOHDgm+tnnzZqufz549++wLAgAAAIA4XuhR9QAAAADgeSA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADAhmQRnCZOnKhcuXLJ3d1dpUqV0p9//vmP8y9atEgFChSQu7u7ihQpotWrVz+nSgEAAAC8iuwenBYsWKDOnTvL399fQUFBKlq0qKpUqaLr168nOP+OHTvUoEEDffHFF9q/f79q1qypmjVr6tChQ8+5cgAAAACvCrsHp9GjR6tVq1Zq0aKFChUqpICAAHl4eGj69OkJzj927Fh9+OGH6tatmwoWLKiBAwfq7bff1oQJE55z5QAAAABeFc72fPOIiAjt27dPvXr1skxzdHSUn5+fdu7cmeAyO3fuVOfOna2mValSRcuXL09w/vDwcIWHh1t+vnv3riQpJCTkP1afdB6GPLR3CUhiIU7Pv33Rjl5OtCUkBXu0I4m29DKiLSGp2KstPS42ExhjbM5r1+B08+ZNRUdHK2PGjFbTM2bMqGPHjiW4zNWrVxOc/+rVqwnOP3ToUPXv3z/e9OzZs//LqgHbeqqnvUvAS4K2hKRAO0JSoS0hqSS3tnTv3j15e3v/4zx2DU7PQ69evayuUMXExOj27dtKly6dHBwc7FjZqyUkJETZs2fXhQsX5OXlZe9y8AKjLSGp0JaQVGhLSAq0I/swxujevXvKkiWLzXntGpzSp08vJycnXbt2zWr6tWvXlClTpgSXyZQpU6Lmd3Nzk5ubm9W01KlT//ui8Z94eXmxMUCSoC0hqdCWkFRoS0gKtKPnz9aVplh2HRzC1dVVxYoV08aNGy3TYmJitHHjRr377rsJLvPuu+9azS9J69evf+L8AAAAAPBf2b2rXufOndWsWTMVL15cJUuW1JgxY/TgwQO1aNFCktS0aVNlzZpVQ4cOlSR17NhR7733nr7//nt99NFHmj9/vvbu3aspU6bY82MAAAAAeInZPTjVq1dPN27cUN++fXX16lX5+voqMDDQMgDE+fPn5ej4/xfGSpcurblz56p379769ttv9dprr2n58uUqXLiwvT4CnoKbm5v8/f3jdZsEEou2hKRCW0JSoS0hKdCOkj8H8zRj7wEAAADAK8zuD8AFAAAAgOSO4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE54pTGoJIDkgu0RACRvBCe8smJiYuTg4CBJioqKUmRkpCQOXpA4MTEx9i4BL4G426PQ0FA9ePDAzhUBbN/w7LyobYvnOOGVN2zYMO3Zs0fBwcHq37+/ypUrZ++S8IKIiYmxPKB7/fr1evjwoXLmzKk333zTzpXhRTVw4ECtW7dOMTExatSokdq1a2fvkvCKMsZYwvycOXN04cIFZc6cWfXr1+cBrfhP4u479+7dK0nKly+fUqdObceqng5XnPDKiXuWY+jQoRo9erSyZ88uV1dX+fn5adq0aZarT8CTGGMsG/4uXbqoWbNmatq0qVq2bCl/f387V4cXRdzt0ejRozVhwgT5+fmpcOHC6tChg3r06GHH6vCqihuavvvuO7Vq1UqBgYFq0aKFmjZtqkOHDtm5QrzIYved3bp1U+3atVWmTBk1btxYc+fOtXNltjnbuwDgeYv9gz1//rzu3LmjRYsW6b333pMk+fv7q02bNoqJiVHz5s3l4uJiz1KRTMU9qAgKCtKuXbv022+/ycPDQ7NmzdLq1at1//59ff/993auFMld7Pbor7/+koeHh37++WdVq1ZNxhi9//77at68uYwxGjFihJ0rxaskdvt24sQJ7d27V1u3blXx4sV16NAhVa5cWX369NGAAQNUpEgRO1eKF0ncfee6deu0evVqzZgxQ5GRkRo/frwmT56sBw8eqFWrVnau9MkITnglrVy5UjVq1FDWrFn10UcfWab3799fDg4Oat++vRwcHNS0aVO5urrasVIkR7Eb/gULFmjRokUqWrSoihUrJknq3r27PDw8tHz5cnXp0oXwBJt27dql0qVLy9PT03LG1cHBQfXr15ckNW/eXA4ODho+fLg9y8QrZtiwYVq/fr28vLyUP39+SVLhwoUVGBioqlWryt/fX/379yc84anF7jtXr16tlStXqmHDhpYT13nz5tV3332nWbNmycHBQS1btrRnqU9EVz28kqpVq6aOHTvq0qVLOn36tKT/HxSiX79+6t27t1q3bq3AwEB7lolk7N69e1q1apW2bdum48ePW6anTp1aHTp0UM2aNbVt27Zku/FH8lG4cGGNHTtWMTExCgoKsnqtfv36mjlzpkaOHKmJEyfaqUK8iooVK6bNmzdr+/btunDhgqRH+8k333xTgYGB2rt3r9q3b69Tp07ZuVK8SK5du6Y+ffro559/thx/SVLu3Lk1ZMgQZc+eXXPmzNHYsWPtWOU/MMBLLjo6+omvffHFF8bT09OsWbMm3ms//fSTiYyMfJal4QUSExNj9V9jjLlw4YL5+uuvTdasWc3QoUOt5g8ODjbdunUzn3/+udUyeLU9aXsUHh5uRowYYRwcHMzYsWPjvb5hwwa2R3hmntQut23bZlxcXEzTpk3NpUuXjDH/vw3ct2+fqVGjxj/uY4GE9p0HDhwwlStXNoULFzZLly61mv/MmTOmSpUqpl27dsly38moenipxR25ZcmSJTp79qzc3d1VsmRJlShRQtKjbjBLlizRokWL9OGHH8ZbR1RUlJyd6dX6Kovbji5cuCA3Nzc5Ozsrbdq0unz5sgYPHqx9+/apdu3a6tq1q2W5+/fvy9PTUw4ODlbrwKspbhuYMWOGzp49q5s3b6phw4YqXLiwUqVKpeHDh6tXr14aO3asvvrqq3jrYHuEpBa3Xf7111+6deuWcufOrXTp0snb21sbNmxQ1apV1aRJEw0aNEhZsmSxulfl8XUAseK2i+DgYHl4eCgmJkYpUqTQ/v371bVrV7m5ualNmzaqUaOGZbmrV6/Kx8dHjo6O8dqa3dk3twHPR9euXU26dOlMpUqVTIYMGczbb79t+vTpY3m9RYsWJnXq1GbZsmX2KxLJUtwzXn379jVvvvmmyZMnjylQoIBZsmSJMcaYK1eumHbt2pl33nnHfP/99/+4DqBLly4mXbp0pnbt2ub11183r7/+uuncubO5ceOGMcaYESNGGBcXFzN48GA7V4pXSffu3U2ePHlM6tSpTYECBcyHH35ozpw5Y4wxZv369cbFxcW0bNnSnD9/3r6F4oUQd783ZMgQU758eVOsWDFTtWpVc+TIEWOMMfv37zcVK1Y0VatWNb/++mu8dSTHq5kEJ7yU4v6xrVixwmTOnNns2rXLGGPMjRs3TO/evU3x4sWtuld99tlnxs/P77nXihfDoEGDTLp06czixYvNvHnzzFdffWUcHR3NDz/8YIwx5vz586ZDhw4mT548Zu7cufYtFslWYGCgyZYtm9m3b59l2qBBg0zZsmVNnz59TEREhAkNDTX+/v6mTJkyhG48FxMmTDBp06Y1mzZtMmfOnDEzZ840fn5+pmjRoubcuXPGGGM2bdpkHBwczJAhQ+xcLV4kvXv3NunSpTM//vijGTBggKlcubJJlSqV2bRpkzHGmD179hg/Pz9TokQJ88cff9i5WtsITnipfPPNN+bWrVtW08aMGWN8fX1NRESEZdqVK1dM27Ztzfvvv28ePHhgmZ4cz27g+bty5YrVz/fu3TPlypUz48aNs5o+cuRI4+DgYLZu3WqMMebs2bNm1KhRJioq6rnViuSrU6dOJigoyGravHnzTJ48eczVq1et+v736NHDvP766+b+/fvGmEf3PCV0bwDwX23cuNHq58jISNO0aVPTpUsXq+lbtmwx5cqVM19//bUJDw83xhgTFBTEvXZ4osePoS5fvmyKFi1q5s+fb5l2//5906JFC+Pl5WUuXrxojDHmzz//NF999dULcQxGh1S8NDZt2qQ7d+7Iy8vLanrq1KkVFRWly5cvS3o0KlCmTJnUokULbd682epBfo6OjlYPpMSrp1KlSvGGEA8NDdXJkyeVKlUqSY/uMzHGqGvXrqpWrZqmTJmiyMhI5cyZU126dJGTk5Oio6PtUT6SiZ07dyo8PDzBoZqjoqL08OFDOTg4KDIyUg4ODurZs6fOnTunTZs2SZJcXV3l4OCQ/Pr344U2ZswY9enTR8YYy77O2dlZDx8+1NGjR63mLV++vEqUKKEdO3ZYpr311ltydnZWVFTUc60byV/ZsmU1ZcoUq2n37t3TqVOnlDFjRkmP7nny9PTUiBEjlDdvXs2YMUMxMTEqUaKExo0b90IcgxGc8NKoWLGipk+fLmdnZ82dO1dXr16VJPn6+urs2bOaNGmSwsLCLAchKVKkUJEiReTp6Wm1Hm5wfbVNnDhRgwYNkiSFhIRIknx8fCw7hVu3bsnZ2dkSjNKmTStjTLyHJTs5OT3fwpGsvPvuu5owYYJlexQbiGrWrCljjL766ivFxMRY2s2NGzeUN29e+fj4WK2H0ISkVK9ePW3dulUODg6WxygYY/T222/r8uXL2rJliyIjIy3zv/3223JyctKDBw+s1sMAJXhcjx491KJFC0n//3iX119/XUWLFtWsWbP08OFDy2APqVOnVsqUKRUcHBzvmCu5H4Ml7+qApxR7hsLBwUFHjhzR0KFD1ahRI129elVFixbV1KlTNWrUKHXr1k0rV67U//73P3Xt2lUeHh4qWLCgnatHchETE6MCBQrIzc1Nw4YNU926dS3PmWjatKkcHR3VpUsX3bt3zxKeLl68qAwZMti5ciQncc+YnjhxQhMmTNCQIUO0ZcsWubu7a8mSJfrzzz/l5+enJUuWaP369frmm2/k6emp4sWL27FyvOwyZ84sJycnrV27Vm+88Ybmz58vBwcHdejQQY6OjurZs6cCAwN1+/ZtBQcH6+eff1a2bNmUJk0ae5eOZK569epyc3PT4MGD1a1bN0VGRsoYo+rVq+vo0aOW5zLFXkmPiYl5IdsVw5Hjhff4MKjGGC1cuFABAQFycXHRzJkzlSlTJi1fvlzffvut7ty5I29vb/n4+GjDhg1ycXFhKFXE6xK1a9culS9fXp9++qnGjh2rTJkyacqUKZo+fbouXryod955R2fPnlVYWJgOHDjAGVhISnhY5pUrVyogIEBRUVHq3bu3ypYtq7///ltNmzbVzZs35ezsrBw5cmjVqlVycXFRdHQ0VyyRpB5vl+fOndOIESM0f/58jR8/Xg0bNtS9e/f00UcfKTg4WFeuXFGuXLkUGRmpvXv3ysXFhW6jSNDjbSsgIEDt2rVTnz591L9/f4WFhalnz576448/5O7urjJlymjHjh26c+fOC7nvJDjhhRb3D3bixIny8PBQkyZN5OTkpEWLFmnChAlyd3fXjBkzlDlzZl26dEmhoaEKDQ1VkSJF5OjoyHNRYNWO9u7dqxw5csjHx0f79+9X2bJl9eGHHyogIEAZMmTQwYMHtWTJEt24cUMZM2bUt99+a+nzTzt6tcVtR6NHj1ZISIj69u0rR0dHrVmzRuPGjVNMTIy+++47lS9f3nLF0hijHDlysD3CMxG3Xa5evVq5c+dWwYIFdfHiRY0cOVK//PKLfvzxRzVs2FBhYWHavXu3Tpw4odSpU6tWrVpycnKiXSJBcdvWyZMnlTVrVqVIkUKzZs1SixYt1LNnTw0aNEgPHz7UypUr9euvv+r+/fvKmjWrfvjhB0vPjRfqRNFzHowCeCa6d+9uMmXKZMaMGWOuXbtmjHk0EtWCBQtMmTJlTOXKlc3Vq1fjLfcijOCCZytuG/juu+9M2bJlzaxZsyyjLQYFBRkPDw9Tq1YtywhAj2MUPcTVrVs3kzVrVjNixAirZ96sXLnSVKlSxVSpUsVs3rw53nJsj5DU4o7I2KtXL5M9e3Yze/ZsExISYox5NBLoV199ZVKlSvXExyiwfUNC4m6v/P39zSeffGJWrVplaS8zZswwjo6O5rvvvrNaLm57ehFHaCQ44YU3ceJEkyFDBnPgwAHLtNihU4159ByncuXKmWLFipng4GA7VIgXwbfffmvSp09v1q9fb27fvm2M+f+Djj179hhPT09Tr149c+LECXuWiWTu559/NhkyZDD79++3THv48KHlAGHz5s2mWrVqplixYuavv/6yU5V41QwcONBkzJjRbNu2zeoRHMY8erZhhw4dTJo0acwvv/xipwrxourZs6dJnz69WbFihbl+/brVa9OmTTPOzs7G39/f6pEwLzKuu+KFZozR8ePH1aRJE7355ps6efKktm/frnHjxilXrlyqV6+e6tatq+DgYP3555/xhioHJOmvv/7S0qVLtXz5cpUpU0Z37tzR0aNHtX79epUuXVrFixfXli1bVKJECeXLl88y6h4QV0xMjE6ePKkaNWrI19dXhw8f1pYtWzRp0iS5ubmpXbt2+uKLL3T79m1t3749waHKgaQWHBys9evXq3///ipTpowuX76soKAgzZ49W4UKFVLjxo01YMAAhYSEaM6cOWrWrJm9S8YLYvPmzZo/f74CAwNVrFgxhYeH68KFCzpw4IBKlCihzz//XA4ODvriiy+UPXt2ffHFF/Yu+T8jOOGF8vhNiA4ODrp165a2bNmiXLlyad68eUqbNq1Kly6t48ePKyAgQJ999pmaNm1q2RkwEATMYzc5e3p66uHDh7p9+7b+97//KSAgQBs3bpQxRt9884127typUqVK6fjx48qdO7cdK0dy8vi2xNHRUSlSpND06dOVJ08ezZ8/X/ny5VOjRo108OBBDR48WHXq1NGnn36qTz/9NMF1AP/V420qOjpat27d0q1bt7R48WItWbJEFy9e1IMHD7R7927duHFDAwcO1NChQ5UpUyY7Vo7k7vF9p5OTkzw8POTh4aHDhw9rxowZWrRokYwxioqK0u7du9WiRQtlypRJH3zwgR0rTzpsrfHCiLszmDRpkmbPni1Jmj59unx9fTVt2jTVrFlTgwYN0vjx49W+fXs9fPhQd+7csfpD5yDl1RYTE2NpDwcPHtStW7eUJk0aFStWTD179lSpUqXk4OCgIUOGaO/evXrrrbe0ZcsWGWP02muv8fBHSLLeHo0fP179+/eXJHXv3l1dunTRsmXL9MUXX2jw4MHq1auXevTooQwZMuj27dtW62F7hKQUt10GBgbq0qVLSp8+verVq6eAgAC1aNFCuXLl0oABAxQUFKT8+fPrxo0bkqQsWbK8EA8ghX3E3XeeP39e4eHh8vLykru7u1q2bKkyZcooODhY/fv317Jly+Tu7m55eHLVqlVfmn0nV5zwwojdGfTo0UNz5sxRu3btdPXqVWXKlEm//fabgoODLc8EiIqKUkBAgLJly6a0adPas2wkI3EPKvr06aMdO3aoffv2qlWrlgYOHKiLFy9ahkt1dHRUeHi4nJyc5OPjYxW+GV0Kse2oe/fumj9/vjp06KALFy4oe/bsGjlypO7du6dUqVJJerQ96tmzpzJkyKCcOXPas2y8xIwxlnb57bffavbs2Ro4cKDq16+vPn36qFatWnJ1ddVrr71mWeb27dvx2iRhHo+Lu+/s16+fDh8+rI4dO6ps2bIaMWKETp06paxZs6p8+fJKlSqV7t69Ky8vL3l4eFit52XYdzIcOV4o48eP14ABA7RhwwYVLVpUkqyGSY2MjNSsWbO0ePFiXbx4Ufv27eP5E4jnu+++09SpUzVjxgyVLFlS6dKls3o9LCxMly9f1tdff61r165p165dL8UGH0lr2rRp+vbbb7V69WoVK1ZM0qNuUQ4ODpahxWfNmqU5c+bo5s2b2rNnD8+NwzPXv39/TZo0ScuWLVPhwoXj3dsbHBysEydOaMCAATp37pz279/P9g1PpWfPnvr55581ceJElStXThkzZrR6PSIiQsHBwfriiy9069Ytbdu27cUaavwp8JeCF0ZUVJQOHTqk9u3bq2jRovr777+1Z88ejR8/Xrlz51aTJk3k6+urQ4cOKU2aNPr11195vg7i2bt3rxYsWKDly5erdOnSunfvnv7++2/t3r1bRYoUka+vr37++WetWrVKISEh2rlz54v5rAk8U8YYHTx4UHXq1FGxYsV05MgRbdu2TQEBATLGqF+/fipevLhu3rypXLlyKTAwkO0Rnrlbt25pw4YNGjVqlEqXLq2rV6/q6NGjmjNnjkqUKKEPPvhAp06dUqdOnZQuXToFBQWxfcNT2bhxo+bOnWs5URQVFaXLly/r5MmTypMnj7Jly6YxY8Zo06ZNCg4OtoSml61tsfVGsvX4VSJnZ2fduXNHa9asUd68eTVlyhR5enqqVKlS2rZtm8aNG6dVq1Zp4MCB8vDwkIODg6KjozlIgZUUKVLI1dVVoaGh+uuvvzRt2jQFBgZKki5fvqzdu3frgw8+ULp06VS7dm0e/ghJ/789iv2vg4OD0qRJo6FDhypr1qxavHixsmXLps8++0xBQUHq1KmTDh48qK+//lqurq5sj/BchIeH6++//1ZwcLACAwM1Z84cnThxQvfu3dP69et1584dffXVVxo7dqxKlSrFQ5fx1GJiYuTj46N06dLp4MGDmjdvnubPny9HR0d5e3srMDBQ77zzjtzd3dW+ffuXdt9JVz0kS3G7skRGRioyMlIeHh66du2aPv/8cx05ckStWrVSlSpVVKxYMS1dulRjxozRr7/+qtSpU0uKH7zw6kmoS9Tp06fVvHlzhYWF6eDBg2rRooUqVaqk4sWL69NPP1W7du3UqlUry/wv29kyJF7cdhQcHCwXFxelSJFCYWFh6t27t9auXWvZHr3xxhvatWuXunbtqqVLl8rHx0cS2yMkvSd1+RwwYIBGjx6t6OhotW3bVpUrV5afn5+qV6+uHDlyaOLEiTbXgVdbQu3ijz/+UIMGDVSwYEHt3btXtWrVUvny5ZU5c2a1b99ekyZNsho572Xdd75cMRAvhbh/sD/88IM2btyomzdvytfXVwMGDNCqVausBoKIiYnRlClTlC1bNnl7e1vWw0HKqy1uO9q6dasuXbqkLFmyqFixYlq4cKF27twpb29vlStXTi4uLoqMjJSTk5Pc3d2t1vMybvjx9OLecD9ixAgFBgbq3r17SpMmjaZOnaoxY8bo/v37SpkypaRHBwv9+vVTunTplCFDBst62B4hKcXdvs2aNUsXLlzQmTNn1LFjR/Xt21d169aVMUYFCxa0LPPw4UOlT5/eaj2EJjwubtuKHXk2b968KleunJYsWaItW7aoffv2qlChglKnTq2QkBB5enoqOjraaj0v676TK05Itr799lv9/PPP6tatmwoVKqRq1aqpevXqmjFjhlKnTq0HDx5o5cqV+uWXX3Tp0iUGgkCCevTooUWLFsnb21tubm6Kjo7W+PHj9c4770h6dDBx48YNtWnTRtevX9euXbte2g0+/r3evXtrypQp+v7775UrVy41btxYKVOm1NatW5UuXTqFhoZq5cqVmjx5sm7dumUZCILtEZ6lbt26ad68eapYsaKCg4O1ceNGjRw5Ul9++aWcnZ117949HT9+XP3799fZs2cZCAL/KO726ttvv9WSJUssw477+vpq4MCBllEYIyMjde/ePTVp0kTBwcH6448/Xol9J6cakCwdPHhQK1as0Jw5c9S5c2elSJFCKVKk0Mcff2zpinf58mXt2rVL3t7eCgoKkouLi6KiojhIgcXUqVM1c+ZMzZ49W/v379dHH32kgwcP6vr165IeXR2YOHGiWrZsqTt37mjHjh2Wm1mBWOfOndO6des0e/ZsNWnSRHfv3lVISIg6dOhgGZHx1q1bOnbsmHLmzKm9e/eyPcIzt2zZMs2bN0+rV6/WzJkz1bt3bz18+FCZM2e2hKPdu3erc+fOioiIsBoIAkhI7PZqzJgxmj59uiZPnqyzZ8/q3Xff1W+//aZz585JehSahg4dqjp16ujmzZvasmXLq7PvNEAyEB0dbfXz3r17TcGCBY0xxixfvtykTJnSBAQEGGOMuXPnjlmxYoUxxphbt26ZmJgYY4wxUVFRz7FiJEex7Si2TbRp08Z0797dGPOoHaVKlcpMnjzZGGPMgwcPzL1798zx48fNtGnTLO0nMjLSDpUjOYm7PQoPDzcnT5406dOnN9HR0Wb16tVW26N79+6ZiRMnmqioKHPv3j22R3hmHt9P/vjjj6ZevXrGGGPmzJljUqVKZSZNmmSMedQuL126ZKKjo8327dvZvuEfxbat6OhoEx4ebmrVqmW+//57Y4wxv/32m9W+MywszBhjzNatW83gwYMtbepVaVtccUKyENuf1t/fX9OmTVOWLFnk5uamvn37qmnTpho1apS+/PJLSdKxY8c0YsQIHThwQGnTprWMdPUqXCLGk5k496Ls379fkZGRkqT8+fNr3bp1aty4sUaMGKHWrVsrOjpaCxYs0MKFC/X666/r888/t5wtoxsL4m6PRowYIR8fHxUvXlxdu3ZV3bp1NXr0aMv26Pz581q2bJl27NihlClTsj3CMxPbLn/88UeFhYUpODhYt27d0ubNm9W2bVsNHz5cbdu2lSTNnTtXI0aMUHh4uEqXLi0nJyfFxMSwfUM8cfedV69elaurq8LCwlS6dGlt3LhRDRo00MiRI9W6dWtFRERoxowZWr9+vcqVK6dvv/3WchXzVWlbBCfYVUxMjOX/lyxZohkzZih//vxKkSKF3nzzTY0ePVqff/655SAlPDxcgwYNko+Pj4oUKWJZlu4wr7aYmBhLG+jUqZMaNGigO3fuKG3atOrYsaM+++wzjR07Vm3atJEk3b17V3PmzNGVK1es1sPB7qst7vZo6dKlmjlzpqpUqSInJydlypRJP/74o5o1a2YZdTEsLEzdunWTq6urypQpY1mW7RGSkolzK/r48ePVqVMnnTx5UrVq1dL169dVsWJFDRs2zBKawsLC9NtvvyksLMxqsBsGgsDjTJx7mtq0aaNPPvlEDx8+VMqUKVWvXj19+umnmjBhguUYLDg4WAsWLNCJEyes1vMq7TsZHALJwqZNm7Ro0SK99tpr6ty5syRp+/bt6tGjhyTpgw8+kLe3t1auXKlr165Z7mliKFXEFRwcrK+//lotWrRQxYoVJUm1a9fW5s2btWPHDqVKlUpRUVFq3bq1bt++re3bt78yZ8nw9NasWaONGzcqXbp06tWrl6RHZ2Lr1KmjiIgIvfHGG8qdO7c2bNig4OBgy8A0bI/wLG3btk2LFi2yDC0eGhqqMWPGaO7cuXr//ffVvXt3nTx5UiNHjtTly5e1d+9eOTs7M0AJbLp+/bpatmypTp066f3339f58+dVv3593bp1S8ePH1doaKjCwsLUpEkThYSEWO5pehWxhYddGWN08OBBffnll5o1a5ZCQkIsr5UpU0ZDhw5VmTJl9Msvv2jdunXKkyeP9u/fb7nxmoMUxPrxxx/1+uuv6+TJk8qdO7dl+tChQ1WoUCGVKVNGJUuWVO3atXXnzh1t27aNG6Uh6f/P6MfExOj69etq0aKFRo8erdOnT1vmyZQpkxYsWKCqVavqzJkz2r9/v4oVK2Y1MA3bIzwra9asUdu2bbVkyRJlzJhRkuTh4aHWrVurUaNG2rRpk/Lnz2858bhnzx7L9o3QhH8yYcIE+fn5KSoqSr6+vpKkLFmyqFevXgoPD1fOnDlVvnx5ffzxx7p27Zp+//33V2cgiARwxQnPXUJnvxYvXix/f395eHhowoQJKlWqlNXroaGh8vDwsPz8Mj6NGonz+Nn9P//8Ux07dtTBgwe1d+9eFShQwKqtrVixQuHh4UqbNq3ef//9l/ap5kicuG3kwYMH8vT01NGjR9WoUSNFRkbqhx9+kJ+f3z+u42V90CPs5/H95IkTJzRy5EjNmzdPbdu21YgRIyyvxd7PuX//fmXNmlWZM2eWo6Mj2zckKHbfaYxRZGSkZs+ereHDhysiIkJnzpyxmjc4OFjTpk2To6OjMmbMqPr167/y+06CE56ruDuDefPm6dChQxo8eLAkadGiRRo2bJgKFy6sjh076u2335YU/6CEbgeI6+DBg5b73fbv36/GjRvLw8NDf/zxh9zd3RUZGSkXF5d4y3Gwi7jhe86cOQoKClKPHj3k4+Ojw4cPq06dOsqbN6969uxpuYeJdoNnLe4+btasWSpbtqxy586tCxcuaMiQIdq5c6eaNWumTp06SUr4RCLdRmHLtWvXlDFjRt29e1erV69W+/bt9cEHH2jBggWSnnyC+lXfBvJXhecm7g38f/75p2bPnq158+Zp3LhxkqQ6deqoS5cuOnLkiMaNG6f9+/dLin/TIaHp1Rb3Bv6dO3eqaNGimj9/viTprbfe0uzZsxUSEqL3339f4eHhcnFxSbBLwau84Yf1geXBgwc1ffp0LV++XFOmTNHNmzf1xhtvaMGCBTp16pSGDx+u7du3S6Ld4NmKu5/866+/9P3336tVq1a6fPmysmfPru7du+udd97RwoULNWbMGEmy3McUF6EJj4u771yzZo0yZ86sgwcPytvbWx9//LEmTJigP/74Q02bNpX0qF3FXs2M61XfBvKXhecmdkPerVs39e3bVzExMQoLC9OYMWM0fPhwSVLDhg3VqVMnHTt2TP7+/vr777/tWTKSmbjDpo4bN067du2SJLVt21azZs2S9Cg8zZ8/X8HBwapYsaIePnz4ym/oEV9sO+rUqZPat28vLy8vpUiRQj/88IMmTJig69evq0iRIlqwYIHOnDmjbt266X//+5+dq8bLLO72bdiwYZbuU1u2bFGzZs10/vx55c6dW927d5evr68WLVqkQYMGSeKEIv5Z3BNFv/zyi2Vb9vHHH+uvv/5SqlSpVL16dY0aNUq///67mjdvLkkJ9tZ45T2vB0YBxhgzd+5ckzp1avPnn3+ahw8fmitXrphmzZqZ4sWLmxEjRljm++mnn8znn38e74F/gDHG9OnTx2TIkMEsWLDA/Pjjj6Zp06bGxcXFzJgxwzLP/v37jbe3t2nVqpUdK0VytmTJEpMmTRoTFBRkwsPDjTHGdOjQwRQpUsT069fP3LhxwxhjzL59+0zDhg3ZHuG5GDVqlEmZMqVZu3atOXLkiBkxYoQpVaqUef/998358+eNMcacPn3a1KtXz7Rq1cry0GXAlu7du5usWbOaSZMmmV69eplSpUqZ1KlTm3379hljjAkJCTHz5s0zTk5Opn///nauNnkiOOG5GjhwoClevLjVAci5c+fMxx9/bLJkyWJ++OEHy/TYJ51zsIK4bt68aYoWLWp+/PFHy7SIiAjTrVs34+LiYubMmWOZfvz4cUs7Ah43bdo089prr5mbN29aHXy2aNHCpEqVyvTr189cu3bNGGMsr7M9wrMUFhZmqlevbnr16mU1fd68eaZgwYKmcuXK5tKlS8YYYy5dumRpj4Qn2HLq1CmTJ08es3jxYsu0EydOmBo1apg0adKYv/76yxhjzJ07d8y6devYdz4BXfXwXMTeY5IhQwZFRETo0qVLkh5dPs6RI4d69eql+/fva/78+Ro7dqykR/1oTZyuC4AkRURE6OLFi0qVKpWkR23I2dlZffv2ValSpdS2bVvLza358uV7pYdNxf8zce4BiW0PTk5OCg8PV1hYmBwcHBQRESFJGjBggFxdXbVq1SrNmjVLDx8+tHSFYnuEZ8nd3V3Ozs46duyY1fT69eurfPnyWr9+vVq0aKGLFy8qS5YscnR0tLovCniSsLAwXb582TKcvSTlzZtXgwYNkoeHhz7++GMdOnRI3t7eqlixIvvOJ2APgGci7k2I0v8fbJQtW1anT5/W2LFjFRoaaplujFGlSpWUP39+LV++XNeuXZNEv+1X3ePtSJIyZ86s9957T5MmTdKNGzcsw6qmTJlSr732mvLly6fGjRtr9+7dlvbFPU6vtscPLGNDVP369eXs7KzWrVsrOjparq6ukqTbt2/rww8/VMGCBRUQEKDbt2/bpW683BLavhljVKpUKZ08eVKbN2+2ujnf19dXNWrUkLOzs0aOHGl5jTCPx5kEBsx+44039Pbbb2vGjBkKCwuT9OgYK3/+/CpSpIicnJxUoUIFXbx40bLPZN8ZH39tSHJxb0KcOnWqunTpok8++USrVq2yjFQ1ZswYde/eXWvXrtWxY8c0ePBgvf766+rZs6e2bNmiPXv22PlTwN7itqMjR45oz549Onr0qCSpQ4cOMsaoS5cuCgkJkaOjoyIiInTnzh2NHDlS1atX13fffaewsLAEdyB4dcRtRxMnTlTTpk1VrVo1DR8+XG5ublq0aJH+97//yc/PT7/99pu2bt2qHj16yMPDQ9OmTdOFCxf066+/2vlT4GUTt12uXbtW8+fP17x58/Tw4UN16dJF3t7e6tatm9atW6fg4GA9ePBAa9euVfny5eXr66s1a9ZYPTAeiBX3RNGVK1d06tQp3b9/X5JUt25dHThwwDIio/ToOWCxz9DMnz+/Ro4cqejoaPadT/BqPr0Kz1TszqB79+6aM2eOPvvsM+XKlUvVq1dX7969NWDAAP3666/q1KmTli1bJicnJ2XIkEH+/v4KDQ1VwYIFlT59ejt/CthT3C6a3377rdasWaPLly+rcOHCypYtm2bMmKGWLVtq+vTpKly4sN577z3973//kzFGFSpU0KpVqxQUFKQUKVLY+ZPA3mLbUc+ePTVr1iw1b95cZcuWVZs2bXTp0iUNHTpUmzdvVtOmTfXNN98oMjJSOXLk0NixYxUeHq58+fIpZ86cdv4UeNnEtssePXpo7ty5KlCggI4dO6Yff/xRw4YN0/r161W1alX16tVLt2/fVpo0aRQeHq5ly5Zp06ZNWrhwoaVrKRAr7r6zb9++2rRpkw4cOKAqVaqodOnS6ty5sy5cuKClS5dqzZo1qlChgtatWydjjKpWraqpU6fq6tWrXGn6J/a4sQovv7Vr15ocOXKYoKAgY8yjUakcHBzM3LlzLfNcuXLFHD582OzevdtyY2uPHj1M3rx5LTe/4tU2fPhwky5dOrN161YTEhJiOnbsaBwcHMzevXuNMY9Gzuvdu7dp2rSp6dKli2VktObNm5vGjRubhw8fctM0zM6dO03evHnNtm3bjDHGbNu2zTg7O5tp06ZZ5omJiTF///23OXHihKXN9O7d2+TOnducO3fOLnXj5TZt2jSTOXNmy/YsICDAODk5mZUrVxpjHg16s379ejNmzBgzbdo0y836X375pSlfvry5d++e3WpH8jZgwACTLl06ExgYaI4fP24ZAOLMmTPm4cOHZsGCBaZBgwamUqVKplmzZiYsLMwYY0ydOnVM586dTVRUFPvOJyA44ZlYvHixqVq1qjHm0RDkKVOmNJMmTTLGPBqx5fDhw1bz79+/39SrV89kyJDB7N+//3mXi2TowYMHplatWmbmzJnGGGNWrVplUqVKZaZOnWqMMSYyMjLeMnfu3DGdO3c2adKkidfG8OqJ3fGvWbPGlC5d2hjzaNuUMmVKExAQYIwxJjg42GzevNlquUOHDpnGjRub9OnTsz1Ckottl127djUdOnQwxhgzf/584+3tbdlPhoSEmODgYKvldu/ebTp06GDSpk1rDhw48Fxrxovj6tWr5r333jMrVqwwxhizYcMG4+npaX766ad488buRyMjI0337t1NunTpzLFjx55rvS8a7nHCfxYSEqKbN29aTbtz544uX76sFStWqE2bNhoxYoTatm0r6dETq4cOHapbt25JenRpOU2aNMqVK5c2b94sX1/f5/0RkAy5uLjo8uXLSpcunVatWqV69eppxIgRatmypSIjIzVlyhStXLnSMv/Fixc1YsQIbdmyRZs2bVKhQoXsWD3s5ebNm7pw4YKk/x9cxsvLS/fu3dO4ceP0+eefa+TIkfryyy8lSbt379bAgQN15swZyzo8PT1VqlQp/fHHH2yPkCTijk7m4OCgmJgYXbhwQXny5FFQUJBatmypYcOGqW3btoqJidHPP/+s5cuXWy13+vRpBQUFafPmzXrzzTft8THwAnB3d1dwcLAKFSqkX3/9VTVr1tSoUaP0xRdfKDw8XNOmTdO+ffskSc7Ozjp58qTatm2rFStWaP369cqfP7+dP0EyZ+/khhfb/PnzTeXKlU2OHDlMs2bNzI4dO4wxj7rhlS9f3jg4OJhRo0ZZ5g8NDTXVq1c3TZs2jXcZmOejvLr++OMP8+OPP5rvv//eXLhwwRjz6IpTvXr1TOXKlU2aNGksZ2KNMeb8+fOmatWq5pdffrFaz4kTJyzP3cGrZ+7cueadd94xWbJkMe+++67ZsmWLiYiIMJcuXTI1atQw7u7u5rvvvrPMH/vMnPr168fb/rA9QlJZtWqV+eabb0zjxo3N4sWLzf37940xxvzyyy/G3d3dODo6WnVjv3fvnvnggw+s2mqsu3fvPre6kfzt27fPLF++3KxYscKEhIQYYx5dcfL19TXNmjUzadOmNRMnTrTMf+TIEVOtWjVLd9BYO3futOx78c8ITvjXAgICTKpUqUyfPn3M0KFDTYoUKcwnn3xiwsLCTFRUlJk8ebJ5++23Tc2aNc2ff/5pli5daj788ENTpEgRy+VhDk7w008/mWzZspm33nrLZM6c2eTIkcOcPn3aGGPMjh07jIeHhylXrpy5ffu2iY6ONjdv3jTVqlUzZcuWtfT5py82AgICjKenpxk2bJiZOXOmef31103JkiUtB6mLFi0yb731lqlataqZMWOGmTFjhqlcuTLbIzxTU6ZMMd7e3qZp06YmV65cJkOGDOb777830dHR5sqVK6Z169YmS5YsZtOmTSY0NNScPHnSfPjhh6ZYsWIJdkcGYk2bNs3kzp3b5MqVy2TKlMlUq1bN3L592xhjzOzZs42Dg4Np1KiRZf6QkBBTrVo1U6lSJfad/wHBCf/KTz/9ZNzc3Myvv/5qmdapUyfj4OBguSfg4cOH5qeffjLlypUzKVKkMCVKlDC1atUyERERxhjDU6lhJk+ebFxdXc3ChQvN3bt3zYIFC4yDg4Np3769pZ0sX77cuLm5mXfffde8/fbbpmzZssbX15d2BIuffvrJuLi4mOXLl1umDR482Dg4OJg1a9ZYps2fP980atTIeHl5mffee880bNiQdoRnZvr06cbJycmsXr3aGPMomOfNm9eUL1/eMs/27dtNkyZNjLOzs8mZM6cpWrSoKVu2LO0S/yh23zl37lxz/vx54+/vb5ycnCxXlyIiIsygQYOMg4ODqV27tvn0009NhQoVTJEiRSxtixNF/46DMQzUjqdnjNHNmzeVMWNGlS1bVqtWrVKqVKkkSX5+ftq0aZNWrlwpBwcHVahQwTIc9Pnz5+Xl5SVvb285ODgoKipKzs6Mhv8q27Rpk/z8/DR9+nQ1b95c0qP75XLkyKEqVapowYIFCg8Pl5ubmw4dOqSNGzfqxo0byp8/vxo2bCgnJyfaEXT//n29/fbbioyM1OHDh+Xh4SFJqly5sjZs2KDJkycrJiZGderUkbe3t5ycnHTr1i2lTp1ajo6ObI/wTGzbtk3ly5dXt27dNHz4cMv0EiVK6M6dO/rtt99UoEABy/QdO3bo8uXLSp8+vcqXLy9HR0faJRL022+/6ZNPPtH8+fNVt25dSdKpU6f02muvxWtvv/76q1auXKmYmBjlz59fnTp1krOzM23rPyA44V9ZuXKlateurTZt2mjw4MFq3ry59u7dq/fee085cuTQuHHjVLhwYaVLl041atRQ9erV5ePjI8n6wX94dc2ZM0ejR49Wjhw5NGfOHHl4eKh27dpasWKFypQpo4wZM+r+/fv68ssv5evrqxw5clgtHx0dzbMmIOnRA5KrVaumQoUKaenSpWrSpIn279+vxo0by83NTbNnz5aLi4vc3NxUvXp1NWjQQHnz5pX06GRQ7CASQFK5d++ePvzwQzk7O+vbb79VlSpVVLduXa1Zs0ZFixaVs7Oz7t27pzx58qhdu3bKkiWL1U35bN+QkJiYGPn7+2vhwoWqW7euBg4cKEmqXbu2li5dqk8++URp06ZVhgwZ1LRpU+XPnz9eO6Jt/TcEJyRabPBZuXKlPvnkE/n4+MjHx0erVq1StmzZJEnnzp3TX3/9pREjRsjHx0dLliwhLMFKTEyMFi1apPHjxytt2rSKiYnRlStX9MMPP6hAgQLaunWrtm7dqt9++01XrlxRv3791LNnT3uXjWTq6NGj+uCDD3Tr1i3ly5dPq1evVvbs2S2vr1q1SqtWrdLJkycVGBjI9gjPTOyBaUhIiGrUqKGoqCgZYxQSEqL169crVapUcnV11fz58xUYGKglS5aobt26mjFjhiQR5PGPQkNDNXLkSAUGBqpixYo6cuSIzp49K39/fxUoUECzZ8/WoUOHtHXrVnl4eGj48OFq1KiRvct+aRCc8K/EhqcNGzaoSpUqatCggcaNG6e0adPGO4Mb+zNndhErti3ExMRowYIFmjBhgvbt26cdO3bo7bfftpr32LFjOnHihKpWrUrXAvyjY8eOqXbt2vL29tbq1avl7e39xC4pXPnGsxQ3PNWpU0e///67Jk2apJYtW8abd+/evXr77bdpj7ApdrsVGhqqYcOGaeHChbp69ap2795tuWIZu39dt26djh8/rrZt27LvTEIEJ/xrsX/Aq1evVvXq1dWmTRv17dtXGTNmlGR9OZiDFDwubnhauHChJkyYoNSpU2vGjBlKly6dIiIi5OrqarUM/bJhS+yVpzfeeEOzZ89WhgwZJFmfwJE4q49nL3YfeP/+fdWoUUMPHz5Uz5499dFHHyV4jyZdqPA0Yo+nwsLCNGLECK1cuVKVKlVS//795ebmpsjISLm4uFgtw74z6RCc8I/iBp779+8rZcqUCb6+atUqffLJJ2rXrp169eqlzJkz26NcvGAev/I0ceJEeXt7a+bMmUqXLh2BG//K0aNHVaVKFb3xxhv65ZdfLCdzgOctNgzdu3fPEp6+/fZbrqDjqTxpH/j4lad169apXLlyGjRokNzc3Nh3PkN8q/hHsX94nTp10siRI3X//v14r8fExOijjz7Sr7/+qgkTJmjevHn2KBXJXNxzNHHP+htj5OjoqHr16qlDhw66f/++qlWrppCQEDb8sIiJiXnqeQsWLKh169Zpw4YNGjZs2DOsCq86W+eenZycFB0drVSpUunXX3+Vp6envvnmG+3ates5VYgXVey+UZKuX79u9VrssZeHh4d69uypKlWqaMeOHfrqq68UGRnJvvMZ4nQHEhT3fqS//vpLixYt0qJFi+JdcZL+/w+4WrVq2rZtm0qWLPm8y0Uy9aSzXg4ODpYzsXHDU926dRUaGqo9e/Yk2Nbwaorbjo4fPy5XV1c5OjoqZ86cT1ymQIECOnnypGXAGiCpxW2XoaGhCgsLU7p06eK9Hjc8LVmyRL1799a7775rr7LxAtiwYYN2796t7777Tu3bt1dwcLB++eUXq+7rccNTjx49FBISogcPHnAl8xmjqx7+0ahRoxQSEqKIiAibZ27jhi360yLuQcXkyZO1c+dORUVFqWDBgvruu+/izZ/QICJ0N0Dc9vDdd99pyZIlevDggaKjo9W5c2e1adPGZsjm3hEktbjtctCgQdq+fbv+/PNPNWnSRKVLl7Y8Xycu7mnC0wgLC1OXLl20Z88epUqVSkFBQdq5c6cKFiyY4Pyx+8nw8HC5uroyGNczxhEJnigsLEx79uzRoEGDdOzYMZvzx/0jJTQhNvD06NFD/fr1U7Zs2VSoUCH5+/urWbNm8eZPaGNPaEJsexgxYoQmT56s8ePHa9q0aerZs6d69uwpf39/m+vg4BRJLbZd9unTR+PGjVPTpk01b948/f777xo5cqTOnj0bb5nH94u0SyQkRYoUGjVqlBwdHbV582a1aNHCEpoS6rLs6OgoY4zc3NwITc8BR7ewePyPLUWKFPrhhx+UMWNGTZkyRevWrVPlypX5o8RT27Vrl5YtW6bFixerTJkyWrFihdzd3fXOO+9YzRfbpmhXSEhUVJT++OMPff311/rggw8kSZUrV1auXLlUs2ZNvfXWW2rcuLGdq8Sr5sSJE1q5cqXmz5+vihUratu2bTp+/LgCAgKUK1curighUeL2sIiMjFTRokWVL18+/fnnnxo6dKh69eolR0fHBHv0xN13sh99tjidC0mP/mDjdo8KDw+XJGXJkkW9e/dWvXr19Omnn2rbtm1WQ/oC/+TKlSvy9PRUmTJltHz5cjVu3Fjff/+92rZtq3v37mnlypWS2NDD2uPbl9DQUB0/ftwyPSYmRlFRUapRo4Zat26tOXPmKDw8PFEDSAD/lYuLi6Kjo/Xee+9pyZIlqlq1qsaMGaPmzZsrNDRUS5cu1cWLF+1dJl4AcUPTggULdOvWLU2ZMkUTJ07U22+/rRUrVmjo0KGS/v/KJW3LPghOsPqDnTBhgurWratPPvlEo0aNkiT5+Pho9OjR+uyzz/Thhx9q+/bthCfEk9BBa9asWZUtWzYFBASoSZMmGjVqlL788ktJ0r59+7RgwQKdOnXqeZeKZCzuSZyzZ88qKipKXl5eqlmzpubOnavDhw/L0dHRss1KlSqVHBwc5ObmRtdOPDOx+7u4+72HDx8qODhYgwYNUqtWrTRs2DC1adNGknTo0CHNmjVLly5dsku9eHHEHT2vV69e+uabb7R06VKFhIQoderU+u6771SiRAn99ttv6t+/v0JDQ+Xn56chQ4bYufJXE3sZWP3BDh06VHny5NEHH3yg7t27q0ePHnrw4IHSpUunH374QXXq1FG5cuX0v//9j6sEsIi74Z8yZYpu374t6dFB7enTp9WuXTv17t3bEppiH9xnjFGePHnsVjeSl7gncQYMGKCePXvq999/lyR9/PHHypMnj3r16qWjR49aHgB54MABZc2a1Z5l4yUXN8zfuXNH9+/fV1RUlAoUKKBGjRqpf//+atmypdq3by/p0fZt4MCBiomJUYkSJexZOl4AsW1ryJAh+umnn7Ry5Up16NBBXl5eiomJUaZMmeTv769y5cpp1qxZKlCggG7duqUxY8bYt/BXFKPqQZK0ePFi9ezZU7Nnz9Y777yj9evXq1q1ajLGqGnTppowYYI8PDx048YNTZ48WT179mQACEiyPtj9+++/VaVKFfn4+GjdunXy9vZWYGCgPvnkEzVo0EBly5ZV+vTpNWHCBF2/fl1BQUFydnbmvjlY6dmzp6ZNm6apU6fqnXfeUaZMmSTJ8qy4Xbt2qWjRogoJCVFMTIyCgoLk4uJCO0KSi9umRowYocDAQMvD4KdPny5nZ2d9++23mjt3rnr06KGHDx/qwIEDunr1qvbv3y8XFxdGB4VNISEhatiwoT799FN98cUXOn/+vOV+uXfeeUcNGzZU6tSpdezYMZ09e1Y1a9aUk5MTIxjbAcEJio6O1ty5c3X37l116NBBq1evVqNGjTRq1Cj5+PioZs2a6ty5s/z9/a2G/eUPFo8PyRsUFKSTJ0/q0KFD8vX11YYNG5Q2bVotW7ZMkydP1l9//aXXX39dmTNn1uzZsy33CHADNWKtW7dOrVu31vLly+Xr66vIyEhdv35dp0+fVqlSpRQZGamFCxfq1KlTypgxo9q2bStnZ2e2R3imevfurSlTpuj7779Xrly51LhxY6VOnVqbN29WVFSUZsyYoV9//VXp06dXvnz5NGTIENolntqDBw/k6+ur8uXLq2HDhpaTix4eHvrrr7/Upk0bDRw40GoZ9p32QXB6BSX0vJxbt24pJCREKVOm1Icffqh69eqpe/fuOnXqlMqUKaPr169rwIAB6t27t52rR3I0evRo+fv7a8WKFcqcObN27typ8ePHKzo6Wps3b1batGkVHBysyMhIubu7W+5L4aACj18lCgwMVLdu3bRmzRrdu3dPs2fP1pw5cxQVFaXUqVNr+/bt8vb2tloHBxB4ls6dO6c6depo0KBBqly5slauXKkmTZpo8ODBateunWW+2CtRsWiXSMjjVyBj28ny5cvVvn17hYaGqm3btqpcubIqVKigzp076/z581q0aBFX1JMBjlheMXH/YC9evGgZ9z9DhgxKly6dDh8+rAcPHliG/HV3d9dnn32mxo0bq2TJkvYsHcnEjh07VLp0actN0hEREdqzZ4++/PJLVaxYUZL0+uuvK3v27OrQoYM+/PBDbdiwQWnSpLE6SDbGEJpecXG3R5cvX5aPj4+8vLzk6OioRo0a6ciRI6pRo4Z69+5tuZ9k69atql69utV6ODhFUoobeCIiIhQVFaUzZ87Iz89Pa9asUYMGDSwD3dy/f1/Tpk1Tu3btrEKTMYZ2iXjibvN++uknS7fO+vXr67PPPtP777+v4OBg5cqVyzL/wYMH9eabbxKakgk63b5C4t7AP3DgQNWuXVsVK1ZU+fLlFRgYKOnRs5tOnTql5cuXa/v27WrVqpWOHz+ud955x9KfFq+uWbNmqWzZslq4cKHluUtubm6KjIzU/v37LfM5OTnpgw8+UM2aNbV3715VrlxZd+/elYODg2X0PXYCr7aEBoIICgpS6dKlNXDgQNWoUUNTp07VqFGj1LJlS73++utKmzatPD097Vw5Xnaxgcff318jRoyQj4+Pihcvrq5du6pu3boaPXq0ZaCb8+fPa/Xq1dq5c6fVOti+ISGx27zu3burf//+iomJUYECBVSnTh31799fHh4eypUrl+7fv6+NGzeqRo0aunr1qoYPHy4p/qMaYAcGrxx/f3+TLl06s3LlSnP8+HFTsWJFkzp1anP69GljjDHTpk0zLi4u5vXXXzelSpUyERERxhhjYmJi7Fk2koHg4GDTo0cP4+zsbObPn2+ZPmXKFFO8eHGzcOFCExkZaZk+Y8YM07BhQ1OpUiXTqFEjS1sCYvXo0cP4+PiYBQsWmMuXL8d7PSIiwly/ft18/PHHpnTp0iYqKsoOVeJVMG3aNLNmzRpjjDFLliwxuXLlMn/++ad58OCBad68uXF3dzft27e3zB8aGmqqVatmqlWrZqKjo+1VNl4w69evNzlz5jS7d+82xhizfft24+DgYGbOnGmZZ9u2beazzz4z1apVs+w32fYlD/STecUEBwdr69atmj59uj766COtWLFC+/fv15AhQ5Q7d24ZY/T555+rYsWKevDggQoWLPjEJ1Xj1WKMUerUqTVw4EClSJFCDRs2VIoUKVSjRg3VqlVLS5Ys0aRJk3T//n3VqVNHkZGRWrp0qd566y29/fbbmjx5sq5cuaIcOXLY+6MgmVizZo1mz56ttWvXytfXVzExMbp27ZrOnj2rfPnyKV26dBozZow2btyo27dva/v27XJycuLeESS5KVOmqE2bNtq1a5fWr1+vHTt2qHXr1pbhxIcOHaqTJ09qz549+vzzz5U7d25t2LBBwcHB2rdvnxwdHRk9Dwl6vF3cunVLhQoVUsmSJbVo0SJ9/vnn+vHHH9WkSRPduXNHN27cUJkyZZQmTRoVKFCAY7Bkhr/wV0xISIiCgoL01ltvacOGDWrcuLGGDBmitm3bKjQ0VIMGDdLFixeVK1cuvfHGG5adAX+wrzYT596kqVOnWqbVqlVL8+fPV7p06TRjxgylSZNGY8aMUY4cOVS2bFkdO3ZM/v7+KlGihKKiouhmACtRUVHKli2bsmTJoiNHjqhfv35655131KRJE9WsWVP3799X4cKF5efnpx07dsjFxUVRUVGEJiSp6dOnq127dlq2bJl8fX3VuHFjjR49WqdPn7bMkylTJi1YsEBVq1bVmTNntH//fhUrVswyFH5UVBShCfGYOLdI/PDDDzpw4IDc3d11/fp1zZw5Uy1bttSIESMsXT/XrVunrl276saNG//X3p2GVVW1/wP/MpyDgAgOGQ6ZoRZZiloEOOYjgVPghDiAlIJjajJ4FNQSBR+cILVHUFFQlCRUMKVSNFIIELQErawQMxNQARljXv8X/tmdo5j9Ejxg388r2WeffS0uF3uve6973Qu9e/fmGKw5Uud0FzWth6XWOTo6ChcXF6Gvry927twpHb969aqwsbERMTExT6qJ1MJ4e3sLY2NjsXfvXrFp0yYxYcIEoampKSIiIoQQQhQVFYkLFy6Ibdu2iYMHD0qpBQsWLBCDBw8Wd+/eVWfzSY3q70fK96Xjx4+Lzp07izFjxohnnnlGvPPOO2LHjh3i8OHDwsTERJw9e1blGkxVocZ24MABoaGhIXx9faVjP/zwg+jfv7949dVXxcmTJx95DfZLaohy+uaOHTtEx44dxTfffCN++eUXMWLECCGTyYSfn590Tnl5ubCzsxMzZszg0ohmjCHsU0p5arigoAB1dXXo0KEDAKBXr14IDAzExIkT4erqCgAoKSnBggULUFtbi7Fjx6qt3dR8lJWVqSzEv337No4fPw5/f384OzsDAKZPn45u3bphxowZ0NHRwaRJk9C/f3/0798fAJCcnIyDBw9i//79SEhIeKCMNP07KN+PysvLIZPJIJfLMXr0aGzcuBE//fQTXFxcMHz4cHTo0AG3b9+GgYHBA8VoONNEjSkkJAQLFizA888/j/3792PIkCGwsrKCqakpIiIi4ODggI8++gi6uroYNGgQgIZLjLNfUkPq73kpKSlIT09HYGAgrKysAAATJkxAXl4eLl++jFOnTqG0tBTBwcG4efMmzp8//8CWMdSMqDtyo6a1cuVKMWDAAPHCCy+IFStWSMdnzJghXn75ZWFjYyPc3NzEwIEDRd++faVFiFzo+u9ma2srPD09VY7duHFDtGnTRoSHh6sc//XXX4WZmZmQy+Vi3759Kp9FREQIa2trkZGR0eRtpuZJ+V4SGBgobGxshLW1tZgzZ450vP6+U11dLQoLC8Xo0aPFoEGD+CafmszOnTuFhoaGiI+PF0IIMWjQING9e3eRkJAgKisrhRBCZGZmipdfflm8/fbbIjExUZ3NpRbqxIkTolevXqJjx44iNjZW5bMtW7aI0aNHC5lMJgYOHCjGjx/PQhAtADfAfcoovw3bvn071q5dC4VCgbt37yIgIAB2dnYICwuDjo4Odu3ahZSUFNTU1KBXr15QKBTc6ZwAAJmZmXjxxReho6ODqqoqyOVyAMC0adNQVFSEkJAQdO3aVTrfyckJaWlp6NixI86ePavypqykpAQGBgZq+T2o+Vi+fDnCwsKwePFiGBkZYeXKlRg0aBCio6Ohra2N8vJybN68GWfOnEFhYaG0pomFIKix5eXlwdXVFW5ubrCzs5OODx48GL///jvCwsJgZWUFuVyOS5cuYerUqTAwMEBwcDD69u2rxpZTS7Rs2TLs2LEDo0aNwtatW9GuXTvpMyEEsrKyYGxsDH19fW4M3xKoN26jxnJ/PmxycrIIDAwUn376qXQsKSlJtG7dWjg6OoqSkpIGr8O3HKTclzZs2CBsbW2ltUnh4eHC0tJSuLu7i7y8PCGEEKWlpcLOzk7ExcWpfJc52lQvNjZW9O7dW3zzzTfSz/r6+kJPT08MHTpUest66NAh8cEHH0gl7ZVL2xM1pvz8fOnfyv2soZmnCxcuiGnTpjETg/7SX/UPLy8v0adPH7F69WpRWFgohGj4Gck+1vxxxukpMHnyZHh7e6Nfv34AgMuXL6NPnz4A7u1MPXPmTGkGIDk5Gba2trC3t8eGDRtgbGysxpZTc5eUlIRRo0Zh1KhR2Lt3L3R0dLBhwwYcOnQIhYWFsLS0RGZmJoQQSE9Ph5aWFkvy0gOio6Px008/wdvbG3FxcXB2dsaaNWvw8ssvw9bWFmPGjMGnn36q8paVM03UFMRD1o0ov+UfPHgwcnJysGfPHlhYWEBHR0c6j/c3aohyv9i7dy++/fZb6OrqwszMDI6OjgAADw8PJCQkYNy4cVi4cCGMjIy4jqkF4l//U0Aul6N3794A7j0UXnnlFRw6dAitW7dGcnIyKioqpIWGVlZWOHHiBPbv348dO3aoueXUnFy6dAlff/01EhISpGODBg1CfHw84uPjMW3aNFRXV8PLywsBAQGYNm0aKisrMXToUJw7d07aX4eDCrrfpEmT4OTkhJKSEqxZswZLlizB/PnzYWpqChMTE8TGxmL+/Pkq32HQRE3hYYPU+jR1AEhMTETXrl0xcuRI/PDDDyrn8f5GDanvF0uXLoWXlxeuXbuG1NRUTJ06FYsXLwYAbNq0CUOHDsWxY8fg7++P0tJSBk0tkfomu+hx3Z9Wt23bNnH69Gnp+CeffCK0tbWFQqGQUmHqp4YzMzOZBkOSPXv2iBdffFF06tRJdO3aVbzzzjsqn6ekpIh27dqJCRMmiPLycum4ch9kf6J6yukmyukoP/74o+jevbu4cOGCEEKInJwc4ezsLNLS0pgmTM2C8n1s7ty57Jf0t3311Vfi2WeflQqJVFRUiOjoaKGnpycUCoV03qxZs8TMmTOZzt5CMXB6CtT/8b344ouiW7duIjExUbrZR0ZGSsFT/QNB+Y+Vg10KDg6WKuJ99913YsGCBUImk4lPPvlECPHnIDglJUW0b99eODo6ioKCAnU2mZqh+Ph4sWbNGunnhnL1CwsLRZcuXYSDg4P4+uuvhbW1tRgxYoR0Lgep1Ngetmbkrwat9z8X2S+pIbt37xZxcXHSzwcPHhSmpqaioqLigfPatm0rUlNTpWMN7WtHLQPnnJ8iV65cwXPPPQcXFxckJyejtrYWU6ZMwb59+xAUFISFCxeitrZWZWqYlVv+3WJiYjBv3jxER0fDyckJZmZmcHFxQU1NDW7cuAHgzxQECwsLHD9+HFFRUdi8ebM6m03NTGVlJaKiohAVFYUNGzYAgLTjfT0hBIyMjLBt2zacO3cOs2bNQmVlJT7//HPpXKbnUWNSXnfy1Vdf4ezZs7h48SKAeyl7yv1T2f3PRfZLut/OnTsxa9YslT7UqVMn/Prrr7hw4YLKuebm5pDL5SgrK5OO1fc/puq1PBw1t2D1DwXl8pWJiYmwtLTEO++8I5VUnTJlCv744w+EhYUxP5sklZWV+PLLL2FiYoLs7Gzp+Pr16wEA6enpUCgU6NChA1xdXSGTyWBhYYHMzEy89NJL6mo2NUM6Ojr44IMPsH79ehw6dAh1dXVQKBRSQFR/nwKAkSNHIiMjAwUFBejWrRs0NTVZfpcanRBCet55enoiIiICdXV16NatG6ZNmwZ3d3eV/kn0d9VvnHz48GGMGTNGOt63b18MHjwYW7ZsgY6ODgYMGAAA6NChA9q3b4+qqiqV67DftUysqtfCnDp1CsnJyVixYgUA1TdqyoMPS0tL5OfnIywsDJaWlipvzASruND/l5OTg4CAAKSmpsLR0RFJSUm4cuUKPD090aNHD+zbtw8ZGRm4fv069PX1sX37dvznP/8BAA526QG5ubnw8/NDWloaxo8fD4VCAeDP+1Rubi48PT1hb28PBwcHlc+IGovyM+7SpUuYPn069uzZg7KyMpw4cQJ79+6Fm5tbg89Ror9y8OBBTJ06FSdPnsSIESOk49u2bYOrqyuOHTuGrVu3Qi6XY/r06ejcuTM2bdqEgoICpKSkcPbyKcBRTwtSnw6TnJwMHR0deHl5qbwx09bWRnV1NWQyGVJSUjB48GC89dZbSElJUdm0j0ET1evUqROWLVsGPz8/fPTRRyguLkZGRga6dOkCALCysoKmpiYiIiKQlZWFoUOHSt9l0ET3MzY2ho+PD/z8/HDkyBEIIbBs2TJoamoiJycHDg4OuHXrFsLCwqTvcMBKja3+GRcaGorTp09j+PDh0tv/nj17olWrVggODoaGhgZ8fHygqanJF4r0SPn5+di1axd69eql8vwbN24cbt68CScnJ0yaNAk6OjpSGvwrr7yCdu3a4ZtvvpEqzzJ4atk449TC3Lx5E+vXr0dKSkqDb3Tv//eiRYsQGBjIP1T6S3l5efD390dSUhKmTJkCT09PAEBVVRXkcrnKubzx06MozzxNnDgRM2fOhIODA/Ly8vDdd99BJpOxH1GTys/Px9KlS3H06FEMGzYM0dHR0mc5OTnYvXs3du7cCUdHRwQEBKixpdSSJCQkYOvWrSgqKsKqVasQEhKCjIwMxMbGwsTEROXcnJwcaGlp4ZlnnlFZUkEtGwOnFuhR6TB5eXlYvHgxnJycMHbsWAAc7NKjPaxfse/QP5Gbmwt/f3+cO3cOP/74Izp37oyLFy9CJpNxAEGNrqEZo0uXLiEkJARhYWHYtGkTZs+eLX2Wm5uLoKAgXLlyBYcPH+ZsE/0l5f515swZbN68GWlpadDQ0MDly5dhaGiI+uF0/b6Zyn2K6aBPDwZOLZTyIHfcuHFYtmwZAKikw3z//fccnND/Sf1g9/z58xg+fDjWrl2r7iZRC5abmwuFQoHbt28jNjaWQRM1CeVB6e3btyGEQMeOHQEA2dnZ2LRpE+Lj4+Hl5YVZs2ZJ38vPz0e7du0aHOgS3U+5jyQlJWHdunUoLCzE6tWrYW1t/cA59HRi4NSCMR2GmkJubi6WLl2KVq1aISQkhA8BeiyFhYUwNDRk9TxqEsoDVV9fX8TExKC4uBht27bFunXrYG1tjWvXrqkETzNnznzoNYj+SkMzT8XFxfDy8sKoUaPU3Dp6Ehg4tXBMh6GmUFBQACMjIy6apkbDVBVqSr6+vtiyZQs2btwIPT09HDhwAKmpqfD398e7776LK1euYPv27QgPD8e+ffukNHai/6v7g6fAwECUlpZi/vz5GD9+vJpbR02NgdNTgOkw1FQ42CWi5ua3337Dc889J/1cUFAAGxsbzJ07F66urtLxefPm4dChQ0hISEDv3r2RkZGBU6dOYdGiRczEoIdq6Ll3/wtE5Z/Pnj0LHx8f9OvXD1u2bHmibaUnj4HTU4LpMERE9LQbN24crKyspOI1wL2XhxYWFti8eTMmTpyIiooKtGrVCgBgbm6Ovn37IjQ0VOU6TGOnhigHTUlJSSguLsbQoUOhr6//wLnKwdPFixfRp08fvmj8F+D/8FOibdu20p5ODJqIiOhpNHv2bCxZsgTAvReGwL39w7p06SIFR61atUJVVRWAe/s2NfRMZNBEDakPfBQKBezt7eHk5AQzMzNERUWhtLRU5dz6oiIAYGZmJo3B6OnGwOkpw7cdRET0tKkfoI4ePRpyuRwfffQR3N3d8f333wMAVq1ahaysLLi5uQGAtP/cb7/9BiMjI7W0mVqO+v4lhEBGRgZOnz6NI0eOIDMzE+bm5li1ahUOHjzYYPCkjGOwpx+nJoiIiKhZu3+NiZ6eHuLi4mBoaIj3338f1tbW8PLygp+fH/r27Ys+ffrg6tWrKCoqgp+fnxpbTs2dcnpeVVUVDAwM8Oabb2LIkCEAgMjISLi4uGD9+vXQ0NDA5MmT0bp1a3U2mdSIoTERERE1W8oD2wsXLkAIATc3NwQFBSE6OhobN25Ebm4uXF1d8dlnn8HCwgKtW7fGsGHDkJGRAW1tbdTW1qr5t6Dmqr5v+fr64q233sLAgQNx/vx5/PHHH9I54eHhsLKywsaNG7Fnzx6Vz+jfhcUhiIiIqFlSDppWrVqFU6dOYcGCBZg2bRoA4MCBA1i6dCnGjRuHJUuWoEePHg9cgwWTqCHKs5jh4eFYvHgxfHx8EB8fj4yMDMyZMwfvv/++Sqqnvb29VO6e23T8OzFwIiIiomZHeWC7fPly7Ny5EwcPHsQrr7wCY2Nj6byIiAgsX74cEydOhKurK1599VV1NZlaoJMnT+KLL76ApaUlHBwcAADu7u44e/Ys7O3tsXDhQhgaGkrn1wfz3OPw34mvYIiIiKjZSExMxMCBA6WZpvPnzyMmJgafffYZrKysUFJSgqtXr+LEiRMYM2YMnJycoKGhARcXF3Tv3p2BE/1tSUlJ8PT0xM2bNzFs2DDp+ObNm+Hu7o7Y2Fhoampi3rx5aNu2LQBI1fNYCOLfif/rRERE1Cy89957CA4OVnmTX1dXhzt37kBXVxeXL1/GypUrMXLkSKxevRoDBgzAjRs3MH36dMTFxWHhwoVqbD21NBYWFpg6dSr09PQQGhqKoqIi6bPNmzdj2LBhCAkJwdGjR1W+x6Dp34upekRERNQslJWVQS6XQyaT4aeffoKJiQmKiorg4uKCixcvoqioCE5OThg6dCgmTJiAnj17wsPDA4sXL5auwc1tqSH3zxLV/1xTU4PAwEB8+umneOONN+Dv7482bdpI523duhXz589nnyIADJyIiIioGVAOePbu3Qs/Pz9s2LABdnZ2yM7ORmpqKjp27IjBgwdDLpejrKwMI0aMgIeHh7Q2haghykHTrl27cOHCBdTU1GDIkCFwdnZGbW0tNm7ciCNHjuD1119/IHgCGJDTPQyciIiISK3unw24e/cuxo4di9raWqxYsQK2trZSZbzKykrcvHkTixYtQk5ODlJTUzmgpb9l6dKlCA8Px/Dhw1FRUYGjR49i1qxZ2Lp1K2QyGdavX4/jx4/j+eefx44dO6Cvr6/uJlMzw+IQREREpDbKQVNkZCS6d+8OKysrfP7557Czs4Ovry9qamowduxYaGlpITIyEgcOHEBZWRmSk5OhpaXF2QB6pKSkJERERCAmJgZWVlYAgPj4eNjZ2UFfXx9BQUHw9PRESUkJ8vPzoaurq+YWU3PE1W1ERESkFkIIKWhSKBRQKBQ4evQoCgoKYGBggKNHj0JPTw/r1q1DXFwcAKBfv35wdnbGmTNnIJPJUFNTw6CJVCxZsgRJSUlQTqoqLi6Gnp4eTE1NIYRAbW0trK2tsX//fgQHByMxMREymQxr165FcHCwVD2PSBlnnIiIiEgt6qvnbdmyBaGhoTh58iRMTU2hq6uL2tpaKXiyt7eHv78/qqqqMHHiRPTr1w/AvXUn3NyWlNXW1uLAgQM4ffo0QkND8dprr0FDQwNGRkbIzs7G5cuXMXjwYOn8119/HcbGxigoKADwZ8U85aCeqB57BBEREalNbW0t0tPTsXDhQvTv3x9yuRzAn0GVgYEBYmJiUFJSgi+++ELlu5xpImV1dXXQ0tLC77//DgB49913ce7cOdTU1KB///6YMGECVq5ciXPnzkl9R19fH7q6urh/yT83t6WGsDgEERERqU1VVRXMzc0xcOBAbN++HcC9t/0aGhr4448/cP36dbz00ksoLy+Hjo4OgyV6KOX1cnfu3EG/fv1gamoKf39/vPHGG4iPj0dQUBCuX7+ORYsWwdDQEKGhobh16xbS0tLYt+iROL9NRERET8T91fPqWVpaIjs7G1lZWejRo4f0tv+XX37BsmXLsGnTJpiamgJgWWh6uPq+5eHhgfz8fHTs2BFnzpzB7NmzsWfPHlhbW0NPTw+RkZFwd3eHqakpnnnmGakyI/sWPQpnnIiIiKjJKQdNGRkZKCkpQZcuXdC9e3ekp6dj2LBhcHFxwdy5c9G3b1/cunULbm5uKC0txcmTJ7nehP6W7du3w8fHB19++SWMjIxQUVGByZMnQ0tLC3v37sWAAQMAAHl5edDV1YWBgQE0NDRQU1PD9XL0SAyciIiIqEnVp94BgI+PD6KioqCpqYny8nLY2dkhICAAKSkpmDVrFtq1a4fy8nK0adMG1dXVSEtLg0wme+hsFZEyd3d3XLt2DYcPH5aOFRUVwdzcHO3atUNQUBBef/11lSCJfYv+LvYSIiIialL1QVNgYCBCQ0Oxa9cuXLlyBaNHj8b+/fvx3XffwdraGnFxcVi5ciWmTJmCRYsWIT09XSo5zoEt/ZX60uF3795Fbm6udLyiogKGhoZYvnw5zp07hxkzZuDnn39W+S77Fv1dnHEiIiKiJiWEgBACkydPhpWVFTw8PBAbGwsXFxf897//xdy5c1FRUQEtLS3IZDKV73LdCTXkYbNEKSkpsLW1hbe3NxQKhXQ8OjoaX331FYqKihAeHs4+Rf8IkzmJiIioUTU0qK2srEReXh6GDh2KpKQkODk5YePGjZgzZw6qqqqwY8cODBgwQGWPHYAlx+lBynssRUdHIysrC+bm5nj11VdhaWkJDw8PhISEoKKiAu7u7igsLMTu3bsxZMgQfPzxxwAYkNM/wxknIiIialTV1dWoqalBQUEBjI2NpQHqjBkzkJCQgPz8fAQHB8PZ2RnAvdLRDg4OcHBwwPz589XZdGrmlNfLKRQK7Nq1C506dUJ+fj7s7e2xdOlSPPvsswgODsaaNWvQqlUryOVytGvXTlovR/RPMXAiIiKiRnPixAnExMTg2LFjKCkpwaBBg2Bvbw83Nzf8+OOPmDlzJoqLi5GZmQkAKCwsxPTp01FcXIwzZ85wFoD+lvT0dKxevRorVqyAhYUFQkNDERoaChMTE3z44Yfo2bMn8vLykJiYCD09PdjY2EBLS4vV8+ixMHAiIiKiRrF7926sWrUKjo6OePbZZ2FkZIStW7fizp07cHNzg6+vL6Kjo7F69Wrcvn0bPXr0QHV1NWpra5GSkgKZTMYUKnqkiIgIxMTEQENDA5GRkVIgtHfvXgQHB8PExAReXl4wMzNT+R77Fj0uhtxERET02EJCQrBo0SKEh4dj4sSJUkrU8OHD4efnh+DgYHTq1Anz5s2DlZUVIiMjUVdXB2NjY0yfPp2zAfS3/fzzz0hKSoK+vj5ycnLw3HPPAbiXCqqhoYGdO3fC29sbW7duhYmJifQ9Bk30uDjjRERERI8lJiYGEyZMQGxsLN5++20pAKp/w5+VlQVXV1eUlJTg6NGj6Ny58wPX4GwANUR5TZOybdu2YcuWLRg5ciQ8PDzw/PPPS58FBwfj4sWL+Pjjj1lqnBoVX+sQERHRP1ZZWYkvv/wSJiYm+PXXXwFAJWgSQqBHjx5Yvnw5Ro0ahatXrzYYODFoovspV2e8c+cOampq0KFDB2hra+O9995DaWkpoqKioK2tjffffx/dunUDAMydO7fBaxA9LgZORERE9I/p6Ohg1apV0NHRQUREBMrKyqBQKKClpYW6ujpptqB79+6Qy+UoKytTc4upJVAOeHx9fXHq1ClcvHgRTk5OeOutt2Bvb49ly5ZBCIHo6GhoaWlh/vz5eOGFF6RrKJctJ2oM7E1ERET0WDp16oRly5bB3NwcR44cQUBAAABAU1MTtbW1AIDMzEy89tpr6N27tzqbSi1EfcCzcuVKbNu2DfPmzUNERAS+/fZb+Pv7Y//+/QCA5cuXY/LkyYiMjMSxY8dUrtFQih/R42DgRERERI/N2NgYPj4+DwRP2traKCkpwe7du2FqaoquXbuquaXUUpw6dQqHDx9GbGwspkyZAkNDQ6SnpwMAgoKCEBUVBeDefk7r1q3jHmDU5FgcgoiIiBpNbm4u/Pz8kJaWhkmTJsHT0xPjxo3DtWvXkJ6eDm1t7Ycu+CdSlpWVhejoaCgUCnzxxRdwcnLChg0bYGFhAWtraxgbG2POnDmYM2eO9B0WGaGmxMCJiIiIGlVubi78/f1x/vx5/PLLLzAyMsKlS5e4TxM91KVLl5Cfnw8hBN58800AQE1NDcrLy6Gjo4MJEybgjTfewMqVK6GpqQlbW1tcv34dNjY2CAoKYiBOTwRT9YiIiKhRGRsbw9vbGz179sRrr70mBU01NTUMmugBYWFhmDhxIqZOnQpnZ2e8++67AO6lebZp0wbV1dXIzs6Grq4uNDU1UVpaig4dOuDDDz9EYGAgNDQ0wHkAehI440RERERNorCwEIaGhtDU1OTmttSg+o2TQ0ND0adPH+zcuRM7duzAvn374OjoiNraWty9exezZ89GZWUlLC0tcfbsWdy9exfJycnQ1NRkyXF6YtjLiIiIqEm0bdtWGtgyaKL7xcTEYN68eYiOjoaTkxPMzMzg4uKCmpoa3LhxA8C9/b3at2+POXPmQEdHB0eOHIFcLkdiYiKDJnrieBcjIiKiJsWBLd1PeePk7Oxs6fj69esBAOnp6VAoFGjfvj1cXV1hY2MDGxsblJWVQU9PDxoaGpzFpCeOqXpERERE9MTl5OQgICAAqampcHR0RFJSEq5cuQJPT0/06NED+/btQ0ZGBq5duwYDAwP873//w4gRIwCAM02kFgyciIiIiEgt6svXHzt2DMXFxcjIyECXLl0A/BkcRURE4OrVq/D29uYME6kVAyciIiIiUpu8vDz4+/sjKSkJU6ZMgaenJwCgqqoKcrlc5VyWsyd1YuBERERERGqlvHHy+PHjoVAoADBQouaFgRMRERERqZ3yxsnDhw/H2rVr1d0kIhVcVUdEREREale/cXKPHj1w69YtbmpLzQ5nnIiIiIio2SgoKICRkRE0NTUhhICGhoa6m0QEgIETERERETVDLDlOzQ0DJyIiIiIiokdgGE9ERERERPQIDJyIiIiIiIgegYETERERERHRIzBwIiIiIiIiegQGTkRERERERI/AwImIiIiIiOgRGDgRERERERE9AgMnIiIiIiKiR2DgRERERERE9Aj/D7N0epaiZFgcAAAAAElFTkSuQmCC\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["\n","Best Model based on Lowest MSE: Random Forest Regression with MSE: 0.0944\n","Best Model based on Highest R-squared: Random Forest Regression with R-squared: 0.9234\n"]}]},{"cell_type":"markdown","source":["Anomaly Detection"],"metadata":{"id":"fyYXBjv_NDD1"}},{"cell_type":"code","source":["# Import necessary libraries\n","import pandas as pd  # For data manipulation (e.g., reading CSV files, handling DataFrames)\n","import numpy as np  # For numerical operations, such as array manipulation\n","import matplotlib.pyplot as plt  # For visualizations (e.g., histograms, plots)\n","from sklearn.ensemble import IsolationForest  # Isolation Forest for anomaly detection\n","from sklearn.preprocessing import StandardScaler  # To standardize the features for better model performance\n","from sklearn.model_selection import train_test_split  # For splitting data into training and testing sets\n","from keras.models import Sequential  # Keras to build neural network models\n","from keras.layers import Dense, Input  # Dense layers for building the autoencoder\n","from sklearn.metrics import classification_report  # For evaluating model performance\n","\n","# Load the dataset\n","file_path = \"ECGCvdata.csv\"  # Path to your CSV dataset\n","df = pd.read_csv(file_path)  # Reading the dataset into a pandas DataFrame\n","\n","# Drop unnecessary columns (for example, 'RECORD' column which might not be useful for modeling)\n","df.drop(columns=['RECORD'], inplace=True)  # Drop the 'RECORD' column from the dataset\n","\n","# Separate features (X) and target variable (y)\n","X = df.drop(columns=['ECG_signal'])  # Feature set (drop the 'ECG_signal' column)\n","y = df['ECG_signal']  # Target variable, which indicates the type of heart condition (normal or abnormal)\n","\n","# Encode the target variable (e.g., normal vs abnormal) using LabelEncoder\n","from sklearn.preprocessing import LabelEncoder\n","label_encoder = LabelEncoder()  # Initialize the label encoder to convert labels to numeric values\n","y_encoded = label_encoder.fit_transform(y)  # Encode the target labels (normal = 0, abnormal = 1)\n","\n","# Handle missing values by imputing with the mean of each column (use SimpleImputer)\n","from sklearn.impute import SimpleImputer\n","imputer = SimpleImputer(strategy='mean')  # Replace missing values with the mean of each column\n","X_imputed = imputer.fit_transform(X)  # Apply imputation on the feature set\n","\n","# Standardize the feature set (important for models like Autoencoders, which are sensitive to feature scaling)\n","scaler = StandardScaler()  # Initialize the StandardScaler for feature standardization\n","X_scaled = scaler.fit_transform(X_imputed)  # Scale the features to have zero mean and unit variance\n","\n","# Split the dataset into training and testing sets (80% for training and 20% for testing)\n","X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_encoded, test_size=0.2, random_state=42)\n","\n","# 1. Isolation Forest Model for Anomaly Detection\n","# Initialize the Isolation Forest model with 100 trees and contamination parameter set to 0.1 (10% anomalies expected)\n","isolation_forest = IsolationForest(n_estimators=100, random_state=42, contamination=0.1)\n","\n","# Train the Isolation Forest model on the training data\n","isolation_forest.fit(X_train)\n","\n","# Make predictions on the test set\n","y_pred_isolation_forest = isolation_forest.predict(X_test)\n","\n","# Convert predictions: Isolation Forest gives -1 for anomalies and 1 for normal, so we convert it to 0 (anomalies) and 1 (normal)\n","y_pred_isolation_forest = [1 if x == 1 else 0 for x in y_pred_isolation_forest]\n","\n","# Evaluate the model using classification report (accuracy, precision, recall, F1-score)\n","print(\"Isolation Forest Model Evaluation:\")\n","print(classification_report(y_test, y_pred_isolation_forest, target_names=label_encoder.classes_))\n","\n","# Plot the results of Isolation Forest Anomaly Detection\n","plt.figure(figsize=(10, 5))  # Create a plot with the specified size\n","plt.hist(y_pred_isolation_forest, bins=3, color='skyblue', edgecolor='black')  # Plot histogram for predicted classes\n","plt.title('Isolation Forest Anomaly Detection')  # Set the title of the plot\n","plt.xlabel('Predicted Class')  # Set x-axis label\n","plt.ylabel('Frequency')  # Set y-axis label\n","plt.xticks([0, 1], ['Anomaly', 'Normal'])  # Set x-axis ticks to 'Anomaly' and 'Normal'\n","plt.show()  # Display the plot\n","\n","# 2. Autoencoder Model for Anomaly Detection\n","# Autoencoder model architecture:\n","input_dim = X_train.shape[1]  # Number of features in the dataset (input layer size)\n","\n","# Define the Autoencoder model using Keras (a sequential neural network)\n","autoencoder = Sequential([\n","    Input(shape=(input_dim,)),  # Input layer that accepts the feature set\n","    Dense(64, activation='relu'),  # First hidden layer with 64 neurons and ReLU activation function\n","    Dense(32, activation='relu'),  # Second hidden layer with 32 neurons and ReLU activation function\n","    Dense(64, activation='relu'),  # Third hidden layer with 64 neurons and ReLU activation function\n","    Dense(input_dim, activation='sigmoid')  # Output layer with the same size as input (for reconstruction)\n","])\n","\n","# Compile the model (using Adam optimizer and Mean Squared Error loss function for reconstruction)\n","autoencoder.compile(optimizer='adam', loss='mse')  # MSE is used to measure reconstruction error\n","\n","# Train the Autoencoder model on the training data (X_train, X_train since it's unsupervised learning)\n","autoencoder.fit(X_train, X_train, epochs=20, batch_size=32, validation_data=(X_test, X_test), verbose=1)\n","\n","# Use the trained Autoencoder model to predict (reconstruct) the test set\n","X_test_pred = autoencoder.predict(X_test)\n","\n","# Calculate the reconstruction error (MSE) for each sample in the test set\n","mse = np.mean(np.power(X_test - X_test_pred, 2), axis=1)  # Mean squared error per sample\n","\n","# Define a threshold for anomaly detection: Set threshold as the 95th percentile of reconstruction errors\n","threshold = np.percentile(mse, 95)  # Anomalies are samples with MSE above this threshold\n","\n","# Classify samples as anomalies (1) or normal (0) based on reconstruction error\n","y_pred_autoencoder = [1 if e > threshold else 0 for e in mse]  # 1 = anomaly, 0 = normal\n","\n","# Evaluate the Autoencoder model using classification report\n","print(\"Autoencoder Model Evaluation:\")\n","print(classification_report(y_test, y_pred_autoencoder, target_names=label_encoder.classes_))\n","\n","# Plot the reconstruction error and threshold for anomaly detection\n","plt.figure(figsize=(10, 5))\n","plt.hist(mse, bins=50, color='lightgreen', edgecolor='black')  # Histogram of reconstruction errors\n","plt.axvline(threshold, color='red', linestyle='--', label=f\"Anomaly Threshold ({threshold:.2f})\")  # Threshold line\n","plt.title('Autoencoder Anomaly Detection - Reconstruction Error')  # Set plot title\n","plt.xlabel('Reconstruction Error (MSE)')  # Set x-axis label\n","plt.ylabel('Frequency')  # Set y-axis label\n","plt.legend()  # Display the legend for the threshold line\n","plt.show()  # Display the plot\n","\n","\n","# Visualizing the results\n","# Compare the anomalies detected by both models (Isolation Forest and Autoencoder)\n","plt.figure(figsize=(12, 6))  # Create a plot with two subplots\n","\n","# Plot Isolation Forest results\n","plt.subplot(1, 2, 1)  # Create the first subplot (left)\n","plt.hist(y_pred_isolation_forest, bins=3, color='skyblue', edgecolor='black')\n","plt.title('Isolation Forest Anomaly Detection')  # Set title\n","plt.xlabel('Predicted Class')  # Set x-axis label\n","plt.ylabel('Frequency')  # Set y-axis label\n","plt.xticks([0, 1], ['Anomaly', 'Normal'])  # Set x-axis ticks to 'Anomaly' and 'Normal'\n","\n","# Plot Autoencoder results\n","plt.subplot(1, 2, 2)  # Create the second subplot (right)\n","plt.hist(y_pred_autoencoder, bins=3, color='lightgreen', edgecolor='black')\n","plt.title('Autoencoder Anomaly Detection')  # Set title\n","plt.xlabel('Predicted Class')  # Set x-axis label\n","plt.ylabel('Frequency')  # Set y-axis label\n","plt.xticks([0, 1], ['Anomaly', 'Normal'])  # Set x-axis ticks to 'Anomaly' and 'Normal'\n","\n","# Tighten layout for better spacing between subplots\n","plt.tight_layout()\n","plt.show()  # Display the final comparison plot\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"uyGdc2LvNHXl","executionInfo":{"status":"ok","timestamp":1743542236579,"user_tz":-360,"elapsed":10189,"user":{"displayName":"Hasib Al Tahsin","userId":"09702867651229494535"}},"outputId":"9306baba-0680-45da-8c14-f91524f00919"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Isolation Forest Model Evaluation:\n","              precision    recall  f1-score   support\n","\n","         AFF       0.00      0.00      0.00        60\n","         ARR       0.19      0.68      0.30        62\n","         CHF       0.00      0.00      0.00        60\n","         NSR       0.00      0.00      0.00        58\n","\n","    accuracy                           0.17       240\n","   macro avg       0.05      0.17      0.07       240\n","weighted avg       0.05      0.17      0.08       240\n","\n"]},{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n","  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n","/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n","  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n","/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n","  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x500 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Epoch 1/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 11ms/step - loss: 1.1865 - val_loss: 0.9044\n","Epoch 2/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.8578 - val_loss: 0.6932\n","Epoch 3/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.6990 - val_loss: 0.6451\n","Epoch 4/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step - loss: 0.6583 - val_loss: 0.6137\n","Epoch 5/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 11ms/step - loss: 0.6615 - val_loss: 0.5966\n","Epoch 6/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.6796 - val_loss: 0.5871\n","Epoch 7/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 0.6912 - val_loss: 0.5805\n","Epoch 8/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.6257 - val_loss: 0.5738\n","Epoch 9/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step - loss: 0.6421 - val_loss: 0.5682\n","Epoch 10/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 0.5974 - val_loss: 0.5629\n","Epoch 11/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 0.5765 - val_loss: 0.5598\n","Epoch 12/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 0.6120 - val_loss: 0.5574\n","Epoch 13/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step - loss: 0.5632 - val_loss: 0.5555\n","Epoch 14/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.6034 - val_loss: 0.5534\n","Epoch 15/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.5905 - val_loss: 0.5518\n","Epoch 16/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.5756 - val_loss: 0.5505\n","Epoch 17/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 6ms/step - loss: 0.6207 - val_loss: 0.5491\n","Epoch 18/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 0.5703 - val_loss: 0.5487\n","Epoch 19/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 6ms/step - loss: 0.5800 - val_loss: 0.5473\n","Epoch 20/20\n","\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 0.5837 - val_loss: 0.5470\n","\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 14ms/step\n","Autoencoder Model Evaluation:\n","              precision    recall  f1-score   support\n","\n","         AFF       0.26      1.00      0.42        60\n","         ARR       0.25      0.05      0.08        62\n","         CHF       0.00      0.00      0.00        60\n","         NSR       0.00      0.00      0.00        58\n","\n","    accuracy                           0.26       240\n","   macro avg       0.13      0.26      0.12       240\n","weighted avg       0.13      0.26      0.13       240\n","\n"]},{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n","  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n","/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n","  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n","/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n","  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x500 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 1200x600 with 2 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":[" Clustering and Segmentation using K-Means Clustering and DBSCAN"],"metadata":{"id":"TYCKI5DjOPni"}},{"cell_type":"code","source":["# Import necessary libraries\n","import pandas as pd  # For data manipulation\n","import numpy as np  # For numerical operations\n","import matplotlib.pyplot as plt  # For visualizations\n","from sklearn.cluster import KMeans  # For K-Means clustering\n","from sklearn.preprocessing import StandardScaler  # For scaling features before clustering\n","from sklearn.cluster import DBSCAN  # For DBSCAN clustering\n","from sklearn.decomposition import PCA  # For dimensionality reduction (visualization)\n","from sklearn.metrics import silhouette_score  # For evaluating clustering performance\n","\n","# Load the dataset\n","file_path = \"ECGCvdata.csv\"  # Path to your CSV dataset\n","df = pd.read_csv(file_path)  # Read the dataset into a pandas DataFrame\n","\n","# Drop unnecessary columns (like 'RECORD' if not needed for clustering)\n","df.drop(columns=['RECORD'], inplace=True)  # Drop the 'RECORD' column if not useful\n","\n","# Separate features from the target variable (excluding the target variable 'ECG_signal')\n","X = df.drop(columns=['ECG_signal'])  # Feature set\n","\n","# Handle missing values by imputing with the mean of each column (in case of missing data)\n","from sklearn.impute import SimpleImputer\n","imputer = SimpleImputer(strategy='mean')  # Using the mean to impute missing values\n","X_imputed = imputer.fit_transform(X)  # Apply imputation\n","\n","# Standardize the feature set (important for clustering algorithms like K-Means and DBSCAN)\n","scaler = StandardScaler()  # Initialize the scaler for standardization\n","X_scaled = scaler.fit_transform(X_imputed)  # Scale the features\n","\n","# ==========================\n","# K-Means Clustering\n","# ==========================\n","# Initialize the K-Means model with 3 clusters (adjust the number based on your data)\n","kmeans = KMeans(n_clusters=3, random_state=42)\n","\n","# Train the K-Means model on the scaled features\n","kmeans.fit(X_scaled)\n","\n","# Get the predicted cluster labels (which cluster each sample belongs to)\n","y_kmeans = kmeans.predict(X_scaled)\n","\n","# Add the cluster labels to the original dataframe\n","df['KMeans_Cluster'] = y_kmeans\n","\n","# Visualize the clusters in a 2D plot using PCA (Principal Component Analysis) for dimensionality reduction\n","pca = PCA(n_components=2)  # Reducing data to 2D for visualization\n","X_pca = pca.fit_transform(X_scaled)  # Perform PCA transformation\n","\n","# Plot the K-Means clusters\n","plt.figure(figsize=(10, 6))\n","plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_kmeans, cmap='viridis', s=50)\n","plt.title('K-Means Clustering of Heart Disease Data')\n","plt.xlabel('Principal Component 1')\n","plt.ylabel('Principal Component 2')\n","plt.colorbar(label='Cluster')\n","plt.show()\n","\n","# DBSCAN Clustering\n","# Initialize the DBSCAN model (Epsilon and Minimum Samples can be tuned for better results)\n","dbscan = DBSCAN(eps=0.5, min_samples=5)  # 'eps' is the maximum distance between two points to be considered neighbors\n","\n","# Train the DBSCAN model on the scaled features\n","y_dbscan = dbscan.fit_predict(X_scaled)\n","\n","# Add DBSCAN cluster labels to the original dataframe\n","df['DBSCAN_Cluster'] = y_dbscan\n","\n","# Visualize the DBSCAN results in a 2D plot using PCA for dimensionality reduction\n","X_pca_dbscan = pca.fit_transform(X_scaled)  # Perform PCA again for visualization\n","\n","# Plot the DBSCAN clusters\n","plt.figure(figsize=(10, 6))\n","plt.scatter(X_pca_dbscan[:, 0], X_pca_dbscan[:, 1], c=y_dbscan, cmap='plasma', s=50)\n","plt.title('DBSCAN Clustering of Heart Disease Data')\n","plt.xlabel('Principal Component 1')\n","plt.ylabel('Principal Component 2')\n","plt.colorbar(label='Cluster')\n","plt.show()\n","\n","# Clustering Evaluation (Silhouette Score)\n","# Evaluate the clustering performance using Silhouette Score (higher is better)\n","silhouette_kmeans = silhouette_score(X_scaled, y_kmeans)\n","silhouette_dbscan = silhouette_score(X_scaled, y_dbscan) if len(set(y_dbscan)) > 1 else -1  # DBSCAN might give only 1 cluster\n","\n","# Print silhouette scores for both models\n","print(f'Silhouette Score for K-Means Clustering: {silhouette_kmeans:.3f}')\n","print(f'Silhouette Score for DBSCAN Clustering: {silhouette_dbscan:.3f}')\n","\n","# Compare Clusters\n","# Visualizing both clustering results (K-Means vs DBSCAN)\n","plt.figure(figsize=(12, 6))\n","\n","# Plot K-Means clusters\n","plt.subplot(1, 2, 1)\n","plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_kmeans, cmap='viridis', s=50)\n","plt.title('K-Means Clustering')\n","plt.xlabel('Principal Component 1')\n","plt.ylabel('Principal Component 2')\n","\n","# Plot DBSCAN clusters\n","plt.subplot(1, 2, 2)\n","plt.scatter(X_pca_dbscan[:, 0], X_pca_dbscan[:, 1], c=y_dbscan, cmap='plasma', s=50)\n","plt.title('DBSCAN Clustering')\n","plt.xlabel('Principal Component 1')\n","plt.ylabel('Principal Component 2')\n","\n","plt.tight_layout()\n","plt.show()\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"oxdD17eAOQMB","executionInfo":{"status":"ok","timestamp":1743542403866,"user_tz":-360,"elapsed":1631,"user":{"displayName":"Hasib Al Tahsin","userId":"09702867651229494535"}},"outputId":"39807e8f-1302-45ee-e91e-d90525c49aab"},"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x600 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x600 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Silhouette Score for K-Means Clustering: 0.386\n","Silhouette Score for DBSCAN Clustering: -0.235\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1200x600 with 2 Axes>"],"image/png":"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\n"},"metadata":{}}]}]}